/*
** Read command line params, call search
*/
int
main(int argc, char *argv[]) {
if (argc != 4) {
usage(argv[0]);
return(-1);
}
// plotter is not really a "grid" but why not use the read routine
// to save coding!
grid_t *sonar = readGrid(strcmp(argv[1],"-")?fopen(argv[1],"r"):stdin, TRUE);
grid_t *actual = readGrid(strcmp(argv[2],"-")?fopen(argv[2],"r"):stdin, TRUE);
grid_t *plotter = readGrid(strcmp(argv[3],"-")?fopen(argv[3],"r"):stdin, FALSE);
assert(sonar);
assert(actual);
assert(plotter);
// create output file
char i = argv[2][6];
char output_file_name[] = "actual1.txt.bit";
output_file_name[6] = i;
bit_file_t *bitfile = BitFileOpen(output_file_name, BF_WRITE);
assert(bitfile);
uint32_t bits_sent=0, moves_made=0;
data_t current_position = plotter->data[0];
for(int i = 0 ; i < plotter->width * plotter->height ; i++) {
data_t new_position = plotter->data[i];
moves_made += gridDistance(plotter, current_position, new_position);
current_position = new_position;
//store the PBF of difference between sonar reading and actual height in tempArray
char tempArray[PBFLIMIT];
int inaccuracy = sonar->data[current_position] - actual->data[current_position];
int numBits, i;
numBits = intToPBF(inaccuracy, tempArray, PBFLIMIT);
//put the PBF into output file
for (i = 0; i < numBits; i++) {
BitFilePutBit((int)tempArray[i] - ASCII_ZERO, bitfile);
}
bits_sent += numBits;
}
assert(!BitFileClose(bitfile));
printf("M: %10d B: %10d Bat: %10.1f\n",
moves_made, bits_sent,
(float)moves_made/(float)MOVES_PER_BATTERY + (float)bits_sent);
return 0;
}
/*
** Read command line params, call search
*/
int
main(int argc, char *argv[]) {
if (argc != 4) {
usage(argv[0]);
return(-1);
}
grid_t *sonar = readGrid(strcmp(argv[1],"-")?fopen(argv[1],"r"):stdin, TRUE);
grid_t *plotter = readGrid(strcmp(argv[2],"-")?fopen(argv[2],"r"):stdin, FALSE);
bit_file_t *bitfile = BitFileOpen(argv[3], BF_READ);
assert(sonar);
assert(plotter);
assert(bitfile);
// temporary home for terrain heights
data_t *result = (data_t *)malloc(sizeof(data_t) * plotter->width * plotter->height);
assert(result);
for(uint32_t pos = 0 ; pos < plotter->width * plotter->height ; pos++) {
data_t temp = 0, len = 0, tempLen = 0;
//get the length of the data part of the PBF from the length defining part, store it into "len"
do {
tempLen = 0;
BitFileGetBitsInt(bitfile, &tempLen, 3, sizeof(len));
len += tempLen;
} while (tempLen == 7);
//get the stored data from the data part
for (int i = 0; i < len; i++) {
int lastbit = BitFileGetBit(bitfile);
temp = temp*2 + lastbit;
}
//actual height = sonar reading - inaccuracy
temp = sonar->data[plotter->data[pos]] - temp;
result[plotter->data[pos]] = temp;
}
assert(!BitFileClose(bitfile));
printf("%d %d\n", plotter->width, plotter->height);
for(uint32_t pos = 0 ; pos < plotter->width * plotter->height ; pos++)
printf("%d\n",result[pos]);
free(result);
return 0;
}
int main(int argc, char *argv[]){
int i,j,k;
char intt[200];
int lon_mask[NPIX_MASK], lat_mask[NPIX_MASK];
struct headers gridHeader,thisHeader;
sprintf(intt,"%s%s",INPATH,GRIDNAME);
gridHeader=readHeader(&intt[0]);
int *glon,*glat;//global longitude and latitude of original grid
int *index;
glon=(int *)malloc(gridHeader.ncells*sizeof(int));
glat=(int *)malloc(gridHeader.ncells*sizeof(int));
index=(int *)malloc(gridHeader.ncells*sizeof(int));
readMask(lon_mask,lat_mask);
readGrid(glon,glat);
indexing(lon_mask,lat_mask,glon,glat,index);
printf("%d\n",sizeof(real));
/*SHORT*/
if(sizeof(real)==sizeof(short)){
for(i=0;i<NCOWFILES;i++) convGeneral(index,filecow[i]);//cow file
for(i=0;i<NVAR6;i++) convGeneral(index,fileclim6[i]);//climate
for(i=0;i<NVAR9;i++) convGeneral(index,fileclim9[i]);
for(i=0;i<NVARERA;i++) convGeneral(index,fileclimera[i]);
for(i=0;i<NSDATEFILES;i++) convGeneral(index,filesdate[i]); //sowing data
for(i=0;i<NPOPFILES;i++) convGeneral(index,filepopdens[i]);//Population density
for(i=0;i<NELEVFILES;i++) convGeneral(index,fileelev[i]); //elevation
for(i=0;i<NCROPFILES;i++) convGeneral(index,filelu[i]); //CFT
}
/*drainage & neibour irrigate(LONG)*/
if(sizeof(real)==sizeof(long)){
for(i=0;i<NDRAINFILES;i++) convGeneral(index,filedrain[i]); //drainage
for(i=0;i<NNEIFILES;i++) convGeneral(index,filenei[i]);//neibourring irrigation
}
/*water use & reservoir_info_grand5 & soil (INT)*/
if(sizeof(real)==sizeof(int)){
for(i=0;i<NLAKEFILES;i++) convSoil_Lake(index,filelakes[i]);//lakes
for(i=0;i<NWUSEFILES;i++) convGeneral(index,filewuse[i]);//water use
for(i=0;i<NRESFILES;i++) conv_reservoir(index,fileres[i]);//reservoir
convSoil_Lake(index,filesoil[0]);//soil
}
free(glon);
free(glat);
free(index);
}
/* Ne plus toucher à cette fonction */
int main(int argc, char* argv[]) {
if((argc - 1) != 1) {
printf("Erreur d'argument\n");
return -1;
}
printf("\033[H\033[2J"); // Efface la console sous linux
readGrid(argv[1]);
printf(" ");
for(int i = 0; i < ((gridSize*5)/2) - 6; ++i)
printf("%c", '=');
printf(" FUTOSHIKI ");
for(int i = 0; i < ((gridSize*5)/2) - 6; ++i)
printf("%c", '=');
int res = resolveFutoshiki();
if(res < 0) {
printf("La grille n'a pas de solution\n");
return 0;
}
color(COLOR_GREEN); // Vert
printGrid();
color(COLOR_WHITE); // Blanc
printf("\n ");
for(int i = 0; i < ((gridSize)*5) - 2; ++i)
printf("%c", '=');
printf("\n");
runTest(checkFutushiki, initTest1, 0);
runTest(checkFutushiki, initTest2, 1);
runTest(checkFutushiki, initTest3, 0);
runTest(checkFutushiki, initTest4, 1);
runTest(checkFutushiki, initTest5, 0);
runTest(checkFutushiki, initTest6, 1);
return 0;
}
Visualization::Abstract::DataSet* UnstructuredPlot3DFile::load(const std::vector<std::string>& args) const
{
/* Create result data set: */
DataSet* result=new DataSet;
/* Read the grid structure: */
char gridFilename[1024];
snprintf(gridFilename,sizeof(gridFilename),"%s.grid",args[0].c_str());
readGrid(&result->getDs(),gridFilename);
/* Read the data values: */
char solutionFilename[1024];
snprintf(solutionFilename,sizeof(solutionFilename),"%s.sol",args[0].c_str());
readData(&result->getDs(),solutionFilename);
return result;
}
int sudoki(char *ip, char *port)
{
char *grid;
int fd;
if ((grid = my_malloc(81)) == NULL)
return (1);
memset(grid, 0, 81);
if ((fd = start_connect(ip, port)) == -1)
{
free(grid);
return (1);
}
if (readGrid(grid, fd))
return (1);
free(grid);
return (0);
}
int main(int argc, char **argv) {
wxInitializer wx_initializer;
if ( !wx_initializer ) {
fprintf(stderr, "Failed to initialize the wxWidgets library, aborting.");
return -1;
}
wxCmdLineParser cmd_parser(cmdLineDesc, argc, argv);
long run_count = 10;
wxString grid_path, dict_path;
bool is_rand = false;
bool is_verbose = false;
switch ( cmd_parser.Parse() ) {
case -1:
return 0;
case 0:
cmd_parser.Found(wxT("count"), &run_count);
is_rand = cmd_parser.Found(wxT("rand"));
is_verbose = cmd_parser.Found(wxT("verbose"));
grid_path = cmd_parser.GetParam(0);
dict_path = cmd_parser.GetParam(1);
wxLogDebug(wxT("grid_path = ") + grid_path + wxT("\n"));
wxLogDebug(wxT("dict_path = ") + dict_path + wxT("\n"));
wxLogDebug(wxT("run_count = %d\n"), run_count);
break;
default:
return 0;
}
std::vector< wxLongLong > durs(run_count); // durations
std::vector< wxString > words_out;
DictType dict;
GridType grid;
AllWordsType all_words;
CharsTransType trans_type;
readDict(dict_path, dict);
generateAllWords(dict, all_words, trans_type);
readGrid(grid_path, grid);
if ( is_rand )
srand(time(NULL));
for (long i = 0; i < run_count; ++i) {
if ( !is_rand )
srand(42);
words_out.clear();
durs.at(i) = wxGetLocalTimeMillis();
generateCross(grid,all_words,trans_type,words_out);
if ( words_out.size() == 0 )
wxPrintf(wxT("Error in creating #%-2i!\n"),i+1);
durs.at(i) = wxGetLocalTimeMillis() - durs.at(i);
if ( is_verbose )
wxPrintf(wxT("Time to generate #%-2i is ")
+ durs.at(i).ToString() + wxT(" ms\n"), i+1);
}
wxLongLong tm_total = std::accumulate(durs.begin(),durs.end(), wxLongLong(0,0));
wxLongLong tm_mean = (tm_total + run_count/2) / run_count;
wxPrintf(wxT("Total time = ") + tm_total.ToString() + wxT(" ms.\nMean time = ")
+ tm_mean.ToString() + wxT(" ms.\n"));
return 0;
}
main(int argc,char *argv[])
{
try{
parseCommandArguments(
argc, // in
argv, //in
¶ms, //in/out
paramFile, //out
additionalParams, //out
Error, // aux
prefix //out
);
printf("prefix = [%s]\n",prefix);
printf("Parameters = [%s]\n", paramFile);
printf("AdditionalParameters = [%s]\n",additionalParams);
ParametersAdaptor3DRISM pa(¶ms);
char Error[256];
MGFactoryCollection3DRISM3 *factories= new MGFactoryCollection3DRISM3();
factories->init(&pa);
GridIndependent3DRISM3 *gridIndependent = (GridIndependent3DRISM3 *) factories->m_gridIndependent;
Grid3DRISM grid0(1,1,1,1,1,1);
char prefix0[256];
strcpy(prefix0,prefix);
prefix0[strlen(prefix)-1]=0;
readGrid(prefix0,&grid0);
Nx = grid0.getNx();
Ny = grid0.getNy();
Nz = grid0.getNz();
dx = grid0.getDRx();
dy = grid0.getDRy();
dz = grid0.getDRz();
printf("SIZES =%d x %d x %d \n",Nx,Ny,Nz);
printf("SPACING = %lf ,%lf, %lf \n",dx,dy,dz);
// Grid3DRISM grid0(Nx,Ny,Nz,dx,dy,dz);
Solution3DRISMR *gamma = (Solution3DRISMR *)factories->createSolution(&grid0);
Solution3DRISMR *c = (Solution3DRISMR *)factories->createSolution(&grid0);
Solution3DRISMR *clong= (Solution3DRISMR *)factories->createSolution(&grid0);
Solution3DRISMR *ctotal = (Solution3DRISMR *)factories->createSolution(&grid0);
readFunctionFromFile( prefix, //const char *prefix,
"gamma",//const char *functionName,
gamma //Solution3DRISMR *gamma //out
);
readFunctionFromFile( prefix, //const char *prefix,
"c", //const char *functionName,
c //Solution3DRISMR *gamma //out
);
readFunctionFromFile( prefix, //const char *prefix,
"clong",//const char *functionName,
clong //Solution3DRISMR *gamma //out
);
c->copy(ctotal); // ctotal = c
addSolution3DRISMR(ctotal,clong); //ctotal +=clong
double value_KH= calculateKHFreeEnergy(
gamma, //Solution3DRISMR *gamma,
c, //Solution3DRISMR *c,
clong, //Solution3DRISMR *minusBetaUlong,
gridIndependent->getKBT(), //Real kBT,
gridIndependent->getSiteDensities()->getDensity(),//Real *densities,
gridIndependent->getSiteMultiplicities()->getSiteMultiplicities() //Integer *multiplicities
);
double value_GF= calculateGFFreeEnergy(
gamma, //Solution3DRISMR *gamma,
c, //Solution3DRISMR *c,
clong, //Solution3DRISMR *minusBetaUlong,
gridIndependent->getKBT(), //Real kBT,
gridIndependent->getSiteDensities()->getDensity(),//Real *densities,
gridIndependent->getSiteMultiplicities()->getSiteMultiplicities() //Integer *multiplicities
);
double value_HNC = calculateHNCFreeEnergy(
gamma, //Solution3DRISMR *gamma,
c, //Solution3DRISMR *c,
clong, //Solution3DRISMR *minusBetaUlong,
gridIndependent->getKBT(), //Real kBT,
gridIndependent->getSiteDensities()->getDensity(),//Real *densities,
gridIndependent->getSiteMultiplicities()->getSiteMultiplicities() //Integer *multiplicities
);
double excludedVolume =
calculateExcludedVolume(
gridIndependent->getSolventRDFs(), //TabFunction **solventRDFs,
gamma, //Solution3DRISMR *gamma,
ctotal, //Solution3DRISMR *c,
gridIndependent->getSiteDensities()->getDensity(),//Real *densities,
gridIndependent->getSiteMultiplicities()->getSiteMultiplicities()// Integer *multiplicities
);
double value_MyHNC = calculateMyHNCFreeEnergy(
gamma, //Solution3DRISMR *gamma,
c, //Solution3DRISMR *c,
clong, //Solution3DRISMR *minusBetaUlong,
gridIndependent->getKBT(), //Real kBT,
gridIndependent->getSiteDensities()->getDensity(),//Real *densities,
gridIndependent->getSiteMultiplicities()->getSiteMultiplicities() //Integer *multiplicities
);
double B2A = Units::distanceUnits()->unit2unit("Bohr","Angstr");
double B2A3 = B2A*B2A*B2A;
printf("HNC: %lf [kcal/mol]\n",value_HNC*Units::energyUnits()->unit2unit("Hartree","kcal/mol"));
printf("KH: %lf [kcal/mol]\n",value_KH*Units::energyUnits()->unit2unit("Hartree","kcal/mol"));
printf("GF: %lf [kcal/mol]\n",value_GF*Units::energyUnits()->unit2unit("Hartree","kcal/mol"));
printf("VUA: %lf [Angstr^3]\n", excludedVolume * B2A3 );
// printf("SVP: %lf [kcal/mol]\n",value_MyHNC*Units::energyUnits()->unit2unit("Hartree","kcal/mol"));
NULL_DELETE( gamma );
NULL_DELETE( c );
NULL_DELETE( clong );
NULL_DELETE( ctotal );
NULL_DELETE( factories);
return 0;
}catch(Exception *e)
{
printf("Exception: %s\n",e->toString());
NULL_DELETE(e);
}
return 1;
}
