//TODO: going to need logic to handle incomplete config files void parse_file( char type, char *json, params_t *par ){ /* Parse file and populate applicable data structures */ uint64_t i; JSON_Value *root_value = NULL; JSON_Object *root_object; JSON_Array *array; if( type == 'f' ) root_value = json_parse_file_with_comments( json ); else root_value = json_parse_string_with_comments( json ); root_object = json_value_get_object( root_value ); par->nQ = (uint64_t) json_object_dotget_number( root_object, "scalars.nq" ); par->L = (uint64_t) json_object_dotget_number( root_object, "scalars.lrgs" ); par->res = (uint64_t) json_object_dotget_number( root_object, "scalars.res" ); par->T = json_object_dotget_number( root_object, "scalars.t" ); par->dt = json_object_dotget_number( root_object, "scalars.dt" ); par->al = (double *)malloc( (par->nQ)*sizeof(double) ); par->de = (double *)malloc( (par->nQ)*sizeof(double) ); par->be = (double *)malloc( ((par->nQ)*((par->nQ)-1)/2)*sizeof(double) ); array = json_object_dotget_array( root_object, "coefficients.alpha" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ (par->al)[i] = -json_array_get_number( array, i ); } } array = json_object_dotget_array( root_object, "coefficients.beta" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ (par->be)[i] = -json_array_get_number( array, i ); } } array = json_object_dotget_array( root_object, "coefficients.delta" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ (par->de)[i] = -json_array_get_number( array, i ); } } json_value_free( root_value ); }
/* Testing correctness of parsed values */ void test_suite_2(void) { JSON_Value *root_value; JSON_Object *object; JSON_Array *array; int i; const char *filename = "tests/test_2.txt"; printf("Testing %s:\n", filename); root_value = json_parse_file(filename); TEST(root_value); TEST(json_value_get_type(root_value) == JSONObject); object = json_value_get_object(root_value); TEST(STREQ(json_object_get_string(object, "string"), "lorem ipsum")); TEST(STREQ(json_object_get_string(object, "utf string"), "lorem ipsum")); TEST(json_object_get_number(object, "positive one") == 1.0); TEST(json_object_get_number(object, "negative one") == -1.0); TEST(json_object_get_number(object, "hard to parse number") == -0.000314); TEST(json_object_get_boolean(object, "boolean true") == 1); TEST(json_object_get_boolean(object, "boolean false") == 0); TEST(json_value_get_type(json_object_get_value(object, "null")) == JSONNull); array = json_object_get_array(object, "string array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } array = json_object_get_array(object, "x^2 array"); if (array != NULL) { for (i = 0; i < json_array_get_count(array); i++) { TEST(json_array_get_number(array, i) == (i * i)); } } else { tests_failed++; } TEST(json_object_get_array(object, "non existent array") == NULL); TEST(STREQ(json_object_dotget_string(object, "object.nested string"), "str")); TEST(json_object_dotget_boolean(object, "object.nested true") == 1); TEST(json_object_dotget_boolean(object, "object.nested false") == 0); TEST(json_object_dotget_value(object, "object.nested null") != NULL); TEST(json_object_dotget_number(object, "object.nested number") == 123); TEST(json_object_dotget_value(object, "should.be.null") == NULL); TEST(json_object_dotget_value(object, "should.be.null.") == NULL); TEST(json_object_dotget_value(object, ".") == NULL); TEST(json_object_dotget_value(object, "") == NULL); array = json_object_dotget_array(object, "object.nested array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } TEST(json_object_dotget_boolean(object, "nested true")); json_value_free(root_value); }
/* Testing correctness of parsed values */ void test_suite_2(JSON_Value *root_value) { JSON_Object *root_object; JSON_Array *array; size_t i; TEST(root_value); TEST(json_value_get_type(root_value) == JSONObject); root_object = json_value_get_object(root_value); TEST(STREQ(json_object_get_string(root_object, "string"), "lorem ipsum")); TEST(STREQ(json_object_get_string(root_object, "utf string"), "lorem ipsum")); TEST(STREQ(json_object_get_string(root_object, "utf-8 string"), "あいうえお")); TEST(STREQ(json_object_get_string(root_object, "surrogate string"), "lorem𝄞ipsum𝍧lorem")); TEST(json_object_get_number(root_object, "positive one") == 1.0); TEST(json_object_get_number(root_object, "negative one") == -1.0); TEST(json_object_get_number(root_object, "hard to parse number") == -0.000314); TEST(json_object_get_boolean(root_object, "boolean true") == 1); TEST(json_object_get_boolean(root_object, "boolean false") == 0); TEST(json_value_get_type(json_object_get_value(root_object, "null")) == JSONNull); array = json_object_get_array(root_object, "string array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } array = json_object_get_array(root_object, "x^2 array"); if (array != NULL) { for (i = 0; i < json_array_get_count(array); i++) { TEST(json_array_get_number(array, i) == (i * i)); } } else { tests_failed++; } TEST(json_object_get_array(root_object, "non existent array") == NULL); TEST(STREQ(json_object_dotget_string(root_object, "object.nested string"), "str")); TEST(json_object_dotget_boolean(root_object, "object.nested true") == 1); TEST(json_object_dotget_boolean(root_object, "object.nested false") == 0); TEST(json_object_dotget_value(root_object, "object.nested null") != NULL); TEST(json_object_dotget_number(root_object, "object.nested number") == 123); TEST(json_object_dotget_value(root_object, "should.be.null") == NULL); TEST(json_object_dotget_value(root_object, "should.be.null.") == NULL); TEST(json_object_dotget_value(root_object, ".") == NULL); TEST(json_object_dotget_value(root_object, "") == NULL); array = json_object_dotget_array(root_object, "object.nested array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } TEST(json_object_dotget_boolean(root_object, "nested true")); TEST(STREQ(json_object_get_string(root_object, "/**/"), "comment")); TEST(STREQ(json_object_get_string(root_object, "//"), "comment")); }
/*------------------------------------------------------------------ - Config file format - simplify, don't need xml, but like the structure { "scalars" : { "nq" : 3, "lrgs" : 4, "print" : true "t" : 10.0, "dt" : 0.1 }, "coefficients" : { "alpha" : [0.112, 0.234, 0.253], "beta" : [0.453, 0.533, -0.732, 0.125, -0.653, 0.752], "delta" : [1.0, 1.0, 1.0] } } ------------------------------------------------------------------*/ int main( int argc, char **argv ){ double *hz, *hhxh; /* hamiltonian components */ double *al, *be, *de; fftw_complex *psi; /* State vector */ fftw_complex factor; double T = 10.0, dt = 0.1; uint64_t i, j, k, bcount; uint64_t nQ=3, N, L=4, dim; int *fft_dims, prnt=0; uint64_t testi, testj; int dzi, dzj; //TODO: consider using smaller vars for flags and these fftw_plan plan; /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Parse configuration file - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ //TODO: going to need logic to handle incomplete config files if( argc < 2 ){ fprintf( stderr, "Need a json configuration file. Terminating...\n" ); return 1; } /* Parse file and populate applicable data structures */ { JSON_Value *root_value = NULL; JSON_Object *root_object; JSON_Array *array; root_value = json_parse_file_with_comments( argv[1] ); root_object = json_value_get_object( root_value ); nQ = (uint64_t) json_object_dotget_number( root_object, "scalars.nq" ); prnt = json_object_dotget_boolean( root_object, "scalars.print" ); L = (uint64_t) json_object_dotget_number( root_object, "scalars.lrgs" ); T = json_object_dotget_number( root_object, "scalars.t" ); dt = json_object_dotget_number( root_object, "scalars.dt" ); al = (double *)malloc( nQ*sizeof(double) ); de = (double *)malloc( nQ*sizeof(double) ); be = (double *)malloc( (nQ*(nQ-1)/2)*sizeof(double) ); array = json_object_dotget_array( root_object, "coefficients.alpha" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ al[i] = -json_array_get_number( array, i ); } } array = json_object_dotget_array( root_object, "coefficients.beta" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ be[i] = -json_array_get_number( array, i ); } } array = json_object_dotget_array( root_object, "coefficients.delta" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ de[i] = -json_array_get_number( array, i ); } } json_value_free( root_value ); } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Compute the Hamiltonian and state vector for the simulation - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ /* Create state vector and initialize to 1/sqrt(2^n)*(|00...0> + ... + |11...1>) TODO: keep track of local size and local base */ dim = 1 << nQ; factor = 1.0/sqrt( dim ); fft_dims = (int *)malloc( nQ*sizeof(int) ); psi = (fftw_complex *)malloc( (dim)*sizeof(fftw_complex) ); hz = (double *)calloc( (dim),sizeof(double) ); hhxh = (double *)calloc( (dim),sizeof(double) ); for( i = 0; i < nQ; i++ ){ fft_dims[i] = 2; } plan = fftw_plan_dft( nQ, fft_dims, psi, psi, FFTW_FORWARD, FFTW_MEASURE ); /* Assemble Hamiltonian and state vector */ for( k = 0; k < dim; k++ ){ //TODO: when parallelized, k in dzi test will be ~(k + base) bcount = 0; for( i = 0; i < nQ; i++ ){ testi = 1 << (nQ - i - 1); dzi = ((k/testi) % 2 == 0) ? 1 : -1; hz[k] += al[i] * dzi; hhxh[k] += de[i] * dzi; for( j = i; j < nQ; j++ ){ testj = 1 << (nQ - j - 1); dzj = ((k/testj) % 2 == 0) ? 1 : -1; hz[k] += be[bcount] * dzi * dzj; bcount++; } } psi[k] = factor; } /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Run the Simulation - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ fftw_complex cz, cx; double t; N = (uint64_t)(T / dt); for( i = 0; i < N; i++ ){ t = i*dt; //t0 = (i-1)*dt; //Time-dependent coefficients cz = (-dt * I)*t/(2.0*T); cx = (-dt * I)*(1 - t/T); //Evolve system expMatTimesVec( psi, hz, cz, dim ); //apply Z part fftw_execute( plan ); expMatTimesVec( psi, hhxh, cx, dim ); //apply X part fftw_execute( plan ); expMatTimesVec( psi, hz, cz, dim ); //apply Z part /* TODO: can probably get some minor speedup by incorporating this into expMatTimesVec if needed */ scaleVec( psi, 1.0/dim, dim ); } fftw_destroy_plan( plan ); /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - Check solution and clean up - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */ //TODO: locally, collect all local largests on one // node, find k largest from that subset if( prnt && nQ < 6 ){ for( i = 0; i < dim; i++ ){ printf( "psi[%d] = (%f, %f)\t%f\n", i, creal( psi[i] ), cimag( psi[i] ), cabs( psi[i]*psi[i] ) ); } } else { uint64_t *largest = (uint64_t *)calloc( L, sizeof(uint64_t) ); findLargest( largest, psi, dim, L ); for( i = 0; i < L; ++i ){ printf( "psi[%d] = (%f, %f)\t%f\n", i, creal( psi[largest[L-1-i]] ), cimag( psi[largest[L-1-i]] ), cabs( psi[largest[L-1-i]]*psi[largest[L-1-i]] ) ); } free( largest ); } /* Free work space. */ fftw_free( psi ); free( fft_dims ); free( hz ); free( hhxh ); return 0; }
int main(){ int i, nQ, lrgs; double t, dt; double *al, *be, *de; JSON_Value *root_value = NULL; JSON_Object *root_object; //JSON_Object *scalar_object; //JSON_Object *coeff_object; JSON_Array *array; root_value = json_parse_file_with_comments( "config.json" ); root_object = json_value_get_object( root_value ); //scalar_object = json_value_get_object( root_object, ); //coeff_object = json_value_get_object( root_value ); nQ = (int)json_object_dotget_number( root_object, "scalars.NQ" ); lrgs = (int)json_object_dotget_number( root_object, "scalars.LRGS" ); t = json_object_dotget_number( root_object, "scalars.T" ); dt = json_object_dotget_number( root_object, "scalars.DT" ); al = (double *)malloc( nQ*sizeof(double) ); be = (double *)malloc( ((nQ*(nQ-1))/2)*sizeof(double) ); de = (double *)malloc( nQ*sizeof(double) ); array = json_object_dotget_array( root_object, "coefficients.ALPHA" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ al[i] = json_array_get_number( array, i ); } } array = json_object_dotget_array( root_object, "coefficients.BETA" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ be[i] = json_array_get_number( array, i ); } } array = json_object_dotget_array( root_object, "coefficients.DELTA" ); if( array != NULL ){ for( i = 0; i < json_array_get_count(array); i++ ){ de[i] = json_array_get_number( array, i ); } } json_value_free(root_value); printf("nQ = %d\n", nQ); printf("lrgs = %d\n", lrgs); printf("t = %f\n", t); printf("dt = %f\n\n", dt); for( i = 0; i < nQ; i++ ){ printf("al[%d] = %f ", i, al[i]); } printf("\n\n"); for( i = 0; i < (nQ*nQ-nQ)/2; i++ ){ printf("be[%d] = %f ", i, be[i]); } printf("\n\n"); for( i = 0; i < nQ; i++ ){ printf("de[%d] = %f ", i, de[i]); } printf("\n\n"); free(al); free(be); free(de); return 0; }
int parse_blueprint_json(JSON_Object *blueprint, blueprint_t *bp) { bstring Name, bp_name, name, game_version; uint32_t resource_cost[5]; bp->revision = json_object_get_number(blueprint, "blueprintVersion"); bp_name = bfromcstr(json_object_get_string(blueprint, "blueprintName")); name = bfromcstr(json_object_get_string(blueprint, "Name")); game_version = bfromcstr(json_object_get_string(blueprint, "GameVersion")); bstring param1 = bfromcstr(json_object_get_string(blueprint, "Parameter1")); bstring param2 = bfromcstr(json_object_get_string(blueprint, "Parameter2")); bstring lpos = bfromcstr(json_object_get_string(blueprint, "LocalPosition")); bstring lrot = bfromcstr(json_object_get_string(blueprint, "LocalRotation")); bp->name = name; bp->blueprint_name = bp_name; bp->Name = Name; bp->game_version = game_version; const char* cpos = json_object_get_string(blueprint, "LocalPosition"); bstring pos = bfromcstr(cpos); struct bstrList *pval = bsplit(pos, ','); for (int i = 0; i < 3; i++) { char *ptr; char *str = bstr2cstr(pval->entry[i], '0'); uint32_t n = strtol(str, &ptr, 10); } const char* crot = json_object_get_string(blueprint, "LocalRotation"); bstring rot = bfromcstr(crot); struct bstrList *rval = bsplit(rot, ','); for (int i = 0; i < 4; i++) { char *ptr; char *str = bstr2cstr(rval->entry[i], '0'); double dbl = strtod(str, &ptr); free(str); bp->local_rotation[i] = dbl; } bp->parameter1 = param1; bp->parameter2 = param2; bp->design_changed = json_object_get_boolean(blueprint, "designChanged"); bp->id = json_object_get_number(blueprint, "Id"); bp->force_id = json_object_get_number(blueprint, "ForceId"); bp->item_number = json_object_get_number(blueprint, "ItemNumber"); JSON_Array *jresource_cost = json_object_get_array(blueprint, "ResourceCost"); for (int i = 0; i < 5; i++) bp->resource_cost[i] = (uint32_t) json_array_get_number(jresource_cost, i); JSON_Array *min_coords = json_object_get_array(blueprint, "MinCords"); for (int i = 0; i < 3; i++) bp->min_coords[i] = (int32_t) json_array_get_number(min_coords, i); JSON_Array *max_coords = json_object_get_array(blueprint, "MaxCords"); for (int i = 0; i < 3; i++) bp->max_coords[i] = (int32_t) json_array_get_number(max_coords, i); JSON_Array *csi = json_object_get_array(blueprint, "CSI"); for (int i = 0; i < 40; i++) bp->constructable_special_info[i] = json_array_get_number(csi, i); bp->last_alive_block = (uint32_t) json_object_get_number(blueprint, "LastAliveBlock"); JSON_Array *palette = json_object_get_array(blueprint, "COL"); for(int i = 0; i < 32; i++) { uint32_t rbga = 0; const char* ccolor = json_array_get_string(palette, i); bstring color = bfromcstr(ccolor); // Create array of substrings struct bstrList *values = bsplit(color, ','); for (int n = 0; n < 4; n++) { char *ptr; char *str = bstr2cstr(values->entry[n], '0'); double dbl = strtod(str, &ptr); free(str); bp->color_palette[i].array[n] = round(dbl * 255.0); } bstrListDestroy(values); bdestroy(color); } JSON_Array *material = json_object_get_array(blueprint, "BlockIds"); JSON_Array *position = json_object_get_array(blueprint, "BLP"); JSON_Array *rotation = json_object_get_array(blueprint, "BLR"); JSON_Array *color = json_object_get_array(blueprint, "BCI"); JSON_Array *bp1 = json_object_get_array(blueprint, "BP1"); JSON_Array *bp2 = json_object_get_array(blueprint, "BP2"); JSON_Array *block_string_ids = json_object_get_array(blueprint, "BlockStringDataIds"); JSON_Array *block_data = json_object_get_array(blueprint, "BlockStringData"); bp->total_block_count = (uint32_t) json_object_get_number(blueprint, "TotalBlockCount"); bp->main_block_count = (uint32_t) json_object_get_number(blueprint, "BlockCount"); bp->blocks = calloc(bp->main_block_count, sizeof(block_t)); for (int i = 0; i < bp->main_block_count; i++) { block_t *act = &bp->blocks[i]; act->material = (uint32_t) json_array_get_number(material, i); act->rotation = (uint32_t) json_array_get_number(rotation, i); act->color = (uint32_t) json_array_get_number(color, i); bstring pos_string = bfromcstr(json_array_get_string(position, i)); struct bstrList *pos_list = bsplit(pos_string, ','); for (int n = 0; n < 3; n++) { char *ptr; char *str = bstr2cstr(pos_list->entry[n], '0'); double dbl = strtod(str, &ptr); uint32_t val = round(dbl); act->position.array[n] = val; free(str); } bstrListDestroy(pos_list); bdestroy(pos_string); bstring bp1_string = bfromcstr(json_array_get_string(bp1, i)); struct bstrList *bp1_values = bsplit(bp1_string, ','); for (int n = 0; n < 4; n++) { char *ptr; char *str = bstr2cstr(bp1_values->entry[n], '0'); double dbl = strtod(str, &ptr); act->bp1[n] = dbl; } bstring bp2_string = bfromcstr(json_array_get_string(bp2, i)); struct bstrList *bp2_values = bsplit(bp2_string, ','); for (int n = 0; n < 4; n++) { char *ptr; char *str = bstr2cstr(bp2_values->entry[n], '0'); double dbl = strtod(str, &ptr); uint32_t val = round(dbl); act->bp2[n] = val; } // Only used for lookup, not saved after that since it has no further semantic value const char *cb1 = json_array_get_string(bp1, i); if (act->bp1[3] != 0) { for (int n = 0; n < json_array_get_count(block_string_ids); n++) { uint32_t test_id = json_array_get_number(block_string_ids, n); if (test_id == 0) { break; } if (test_id == act->bp1[3]) { // BlockStringData at index n is the one we want act->string_data = bfromcstr(json_array_get_string(block_data, n)); } } } } JSON_Array *subconstructables = json_object_get_array(blueprint, "SCs"); bp->num_sc = json_array_get_count(subconstructables); bp->SCs = calloc(bp->num_sc, sizeof(blueprint_t)); for (int i = 0; i < bp->num_sc; i++) { JSON_Value *sc_json = json_array_get_value(subconstructables, i); JSON_Object *sc_obj = json_value_get_object(sc_json); int retval = parse_blueprint_json(sc_obj, &bp->SCs[i]); if (retval != 0) return retval; } return 0; }