cuiksystem.h

Go to the documentation of this file.

#ifndef CUIKSYSTEMH
#define CUIKSYSTEMH

#include "constants.h"
#include "equations.h"
#include "variables.h"
#include "statistics.h"
#include "list.h"
#include "box_list.h"
#include "parameters.h"
#include "box.h"
#include "boolean.h"
#include "vector.h"
#include "csmapping.h"
#include "jacobian.h"

#include <stdlib.h>


/************************************************************************************/

#define EQ_MIN_IN_CENTER 0

#define NEWTON_WITHIN_RANGES 0

/************************************************************************************/
#define DEPTH_FIRST_SEARCH 1
/************************************************************************************/

/************************************************************************************/
#define BREADTH_FIRST_SEARCH 2
/************************************************************************************/

/************************************************************************************/
#define MINIMIZATION_SEARCH 3
/************************************************************************************/

/************************************************************************************/
#if (RANDOMNESS)
  #define CUT_POINT 0.45+0.1*randomDouble()
#else
  #define CUT_POINT 0.5
#endif
/************************************************************************************/

/************************************************************************************/
#define MPI_TREAT_BOX_TIMEOUT(cs) (cs->nvariables*SIMPLEX_TIMEOUT*10)
/************************************************************************************/


/************************************************************************************/
#define DIVERGED 1
/************************************************************************************/

/************************************************************************************/
#define CONVERGED_IN_BOX 2
/************************************************************************************/


/************************************************************************************/
#define CONVERGED_IN_GLOBAL 4
/************************************************************************************/

/************************************************************************************/
#define CONVERGED_OUTSIDE_GLOBAL 8
/************************************************************************************/

#define CONVERGED (CONVERGED_IN_BOX|CONVERGED_IN_GLOBAL|CONVERGED_OUTSIDE_GLOBAL)
/************************************************************************************/

typedef struct { 
  Tconstants constants;    
  boolean updated;         
  boolean consistent;      
  boolean empty;           
  boolean scalar;          
  Tstatistics st;          
  unsigned int searchMode; 
  Tequation orig_eqMin;    
  /******************************************************************************/
  /* SIMPLIFIED AND DUMMIFIED SUB-SYTEM                                         */
  /* The dummified system is for internal use only and only used for the linear
     relaxation methods. Other higher-level methods can operate on the simplified
     sistem, without dummification. */
  Tmapping *orig2sd;       
  Tequations equations;    
  Tvariables variables;    
  unsigned int nequations; 
  unsigned int nvariables; 
  boolean *systemVar;      
  boolean *notDummyVar;    
  unsigned int *varType;   
  Tequation eqMin;         
  /******************************************************************************/
  /* SIMPLIFIED SUB-SYTEM                                                       */
  Tmapping *orig2s;             
  boolean simp_empty;           
  Tequations simp_equations;    
  Tvariables simp_variables;    
  unsigned int simp_nequations; 
  unsigned int simp_nvariables; 
  unsigned int simp_nee;        
  unsigned int *simp_tp;        
  Tequation simp_eqMin;         
  TJacobian J;                  
  /******************************************************************************/
  /* ORIGINAL SUB-SYTEM                                                         */
  Tequations orig_equations;    
  Tvariables orig_variables;    
  unsigned int orig_nequations; 
  unsigned int orig_nvariables; 
  boolean *orig_systemVar;      
  boolean *orig_notDummyVar;    
  char **orig_varNames;         
} TCuikSystem;


/****************************************************************************/
/* Methods to initialize/define/re-define CuikSystems (constructors et al.) */
/****************************************************************************/

void InitCuikSystem(TCuikSystem *cs);


void InitCuikSystemFromFile(Tparameters *p,char *filename,TCuikSystem *cs);

void AddCuikSystemFromFile(Tparameters *p,char *filename,TCuikSystem *cs);

void VerifyCuikSystem(Tparameters *p,TCuikSystem *cs);

void CopyCuikSystem(TCuikSystem *cs_dst,TCuikSystem *cs_src);

void CuikSystemMerge(Tparameters *p,TCuikSystem *cs1,TCuikSystem *cs2,TCuikSystem *cs);


boolean CmpBoxesEquation(void *b1,void *b2,void *cs);

void SetCSSearchMode(unsigned int sm,Tequation *eqMin,TCuikSystem *cs);

void AddTerm2SearchCriterion(double w,unsigned int v,double val,TCuikSystem *cs);

/****************************************************************************/
/*     Methods to add individual variables/equations to the cuik system     */
/****************************************************************************/

unsigned int AddVariable2CS(Tvariable *v,TCuikSystem *cs);

void AddEquation2CS(Tparameters *p,Tequation *eq,TCuikSystem *cs);

void AddMatrixEquation2CS(Tparameters *p,TMequation *eq,TCuikSystem *cs);

/****************************************************************************/
/*        Methods to access the data stored in the CuikSystem.              */
/*  These methods provide controlled access to the stored data so that the  */
/*     higher levels can not introduce inconsistancies in the CuikSystem    */
/****************************************************************************/

void GetCSVariables(Tvariables *vs,TCuikSystem *cs);

void GetCSVariableNames(char **varNames,TCuikSystem *cs);

unsigned int GetCSNumVariables(TCuikSystem *cs);


unsigned int GetCSNumSystemVariables(TCuikSystem *cs);

unsigned int GetCSNumNonDummyVariables(TCuikSystem *cs);


void GetCSVariable(unsigned int n,Tvariable *v,TCuikSystem *cs);

void SetCSVariableRange(unsigned int n,Tinterval *r,TCuikSystem *cs);

unsigned int GetCSVariableID(char *name,TCuikSystem *cs);

char *GetCSVariableName(unsigned int id,TCuikSystem *cs);


char *GetCSSystemVariableName(unsigned int id,TCuikSystem *cs);


boolean IsSystemVarInSimpCS(Tparameters *p,char *v,TCuikSystem *cs);

unsigned int GetCSSystemVars(boolean **sv,TCuikSystem *cs);


unsigned int GetCSVarTopology(unsigned int vID,TCuikSystem *cs);

void GetCSEquations(Tequations *eqs,TCuikSystem *cs);

unsigned int GetCSNumEquations(TCuikSystem *cs);

void GetCSEquation(unsigned int n,Tequation *eq,TCuikSystem *cs);

boolean IsCSPolynomial(TCuikSystem *cs);

boolean IsCSScalar(TCuikSystem *cs);

void GetCSJacobian(TJacobian *J,TCuikSystem *cs);

unsigned int GetSimpCSTopology(Tparameters *p,
                               unsigned int **t,TCuikSystem *cs);

unsigned int GetCSTopology(Tparameters *p,
                           unsigned int **t,TCuikSystem *cs);

void GetSimpCSJacobian(Tparameters *p,
                       TJacobian *J,
                       TCuikSystem *cs);

void AddJacobianEquations(Tparameters *p,boolean *selectedVars,TCuikSystem *cs);

void AddSimplifiedJacobianEquations(Tparameters *p,boolean *selectedVars,TCuikSystem *cs);

/****************************************************************************/
/*                    Methods to solve the CuikSystem.                      */
/****************************************************************************/

unsigned int MaxReduction(Tparameters *p,unsigned int varMask,double *r,Tbox *b,TCuikSystem *cs);

boolean SampleCuikSystem(Tparameters *p,char *fname,Tlist *sb,
                         unsigned int nsamples,unsigned int ntries,
                         unsigned int ndof,TCuikSystem *cs);

boolean SampleCuikSystemInBox(Tparameters *p,char *fname,Tlist *sb,
                              unsigned int nsamples,unsigned int ntries,
                              unsigned int ndof,
                              Tbox *init_box,TCuikSystem *cs);


boolean IncrementalSampleCuikSystem(Tparameters *p,char *fname,Tlist *sb,
                                    boolean *fixVars,
                                    unsigned int nsamples,unsigned int ntries,
                                    unsigned int ndof,TCuikSystem *cs);
boolean IncrementalSampleCuikSystemInBox(Tparameters *p,char *fname,Tlist *sb,
                                         boolean *fixVars,
                                         unsigned int nsamples,unsigned int ntries,
                                         unsigned int ndof,
                                         Tbox *init_box,TCuikSystem *cs);

unsigned int CuikNewtonSimp(Tparameters *p,double *x,TCuikSystem *cs);

unsigned int CuikNewtonInBox(Tparameters *p,
                             Tbox *bIn,double *sol,Tbox *b_sol,TCuikSystem *cs);

boolean CuikNewton(Tparameters *p,double *sol,Tbox *b_sol,TCuikSystem *cs);

unsigned int CuikGradientInBox(Tparameters *p,
                               Tbox *bIn,double *sol,Tbox *b_sol,TCuikSystem *cs);

boolean CuikGradient(Tparameters *p,double *sol,Tbox *b_sol,TCuikSystem *cs);


void SolveCuikSystem(Tparameters *p,
                     boolean restart,char *fstate,Tbox *searchSpace,
                     FILE *f_out,Tlist *sol,TCuikSystem *cs);

#if (_USE_MPI)

void MPI_SolveCuikSystem(Tparameters *p,
                         boolean restart,char *fstate,Tbox *searchSpace,
                         FILE *f_out,TCuikSystem *cs);
  void MPI_TreatBox(Tparameters *p,TCuikSystem *cs);
#endif


/****************************************************************************/
/*                           Auxiliary Methods.                             */
/****************************************************************************/
void GenerateInitialBox(Tbox *box,TCuikSystem *cs);

void GenerateSimpInitialBox(Tparameters *p,Tbox *box,TCuikSystem *cs);

boolean RegenerateSolution(Tparameters *p,Tbox *b,TCuikSystem *cs);

unsigned int RegenerateSolutionPoint(Tparameters *p,double *pt,double **rp,TCuikSystem *cs);

void RegenerateOriginalBox(Tparameters *p,Tbox *boxS,Tbox *boxO,TCuikSystem *cs);
  
unsigned int RegenerateOriginalPoint(Tparameters *p,double *s,double **o,TCuikSystem *cs);

unsigned int GenerateSimplifiedPoint(Tparameters *p,double *o,double **s,TCuikSystem *cs);

unsigned int SimplifyBooleanArray(Tparameters *p,boolean *bo,boolean **bs,
                                  TCuikSystem *cs);

unsigned int ComputeSplitDim(Tparameters *p,Tbox *b,TCuikSystem *cs);

boolean PointInSystemBox(Tvector *v,Tbox *b,TCuikSystem *cs);

void EvaluateCSEquations(double *p,double *r,TCuikSystem *cs);

void EvaluateSimpCSEquations(Tparameters *pr,double *p,double *r,TCuikSystem *cs);

void EvaluateSubSetSimpCSEquations(Tparameters *pr,boolean *se,double *p,double *r,TCuikSystem *cs);

double ErrorInCSEquations(double *p,TCuikSystem *cs);

double ErrorInSimpCSEquations(Tparameters *pr,double *p,TCuikSystem *cs);

double EvaluateCSCost(Tparameters *p,boolean simp,double *s,void *cs);

void EvaluateCSJacobian(double *p,double ***J,TCuikSystem *cs);

double ErrorInSolution(Tbox *b,TCuikSystem *cs);

double ErrorInInequalities(Tbox *b,TCuikSystem *cs);

boolean InequalitiesHoldOnPoint(double *p,TCuikSystem *cs);

boolean SimpInequalitiesHoldOnPoint(Tparameters *pr,double *p,TCuikSystem *cs);

double ErrorInSimpInequalitiesOnPoint(Tparameters *pr,double *p,TCuikSystem *cs);


unsigned int ManifoldDimension(Tparameters *pr,double *p,TCuikSystem *cs);

/****************************************************************************/
/*               Output the information in the CuikSystem                   */
/****************************************************************************/

void PrintCuikSystem(Tparameters *p,FILE *f,TCuikSystem *cs);

void PrintCuikSystemWithSimplification(Tparameters *p,FILE *f,TCuikSystem *cs);


void SaveCuikSystemSimplification(Tparameters *p,FILE *f,TCuikSystem *cs);


/****************************************************************************/
/*                                 Destructor                               */
/****************************************************************************/

void DeleteCuikSystem(TCuikSystem *cs);

#endif