Example #1
0
 void SymbolicQr::deepCopyMembers(
     std::map<SharedObjectNode*, SharedObject>& already_copied) {
   LinearSolverInternal::deepCopyMembers(already_copied);
   fact_fcn_ = deepcopy(fact_fcn_, already_copied);
   solv_fcn_N_ = deepcopy(solv_fcn_N_, already_copied);
   solv_fcn_T_ = deepcopy(solv_fcn_T_, already_copied);
 }
 void ImplicitFunctionInternal::deepCopyMembers(std::map<SharedObjectNode*,
                                                SharedObject>& already_copied) {
   FunctionInternal::deepCopyMembers(already_copied);
   f_ = deepcopy(f_, already_copied);
   jac_ = deepcopy(jac_, already_copied);
   linsol_ = deepcopy(linsol_, already_copied);
 }
struct node* deepcopy(struct node* head) {
    if(!head) return NULL;

    struct node* cpy = malloc(sizeof(struct node));
    cpy->data = head->data;

    cpy->left = deepcopy(head->left);
    cpy->right = deepcopy(head->right);

    return cpy;
}
Example #4
0
GslInternal* GslInternal::clone() const{
  // Return a deep copy
  Function f = deepcopy(f_);
  Function q = deepcopy(q_);
  GslInternal* node = new GslInternal(f,q);
  node->setOption(dictionary());
  node->jac_f_ = deepcopy(jac_f_);
  node->dt_f_ = deepcopy(dt_f_);
  if(!node->is_init)
    node->init();
  return node;
}
int main() {
    struct node A, B, C, D, E;
    A.data = 128;
    B.data = 64;
    C.data = 256;
    D.data = 32;
    E.data = 48;

    A.left = &B;
    A.right = &C;
    B.left = &D;
    B.right = 0;
    C.left = 0;
    C.right = 0;
    D.left = 0;
    D.right = &E;
    E.left = 0;
    E.right = 0;

    struct node* cpyTree = deepcopy(&A);
    incTree(cpyTree);

    // Copy tree should be 1 larger than original in all node values
    printInOrder(&A);
    printf("\n");
    printInOrder(cpyTree);
}
Example #6
0
double& Signal::operator[](const unsigned index)
{
  assert(index < len);
  deepcopy();

  if (type == SIG_SAMP)
    return sample[index];
  return sample[0];
}
Example #7
0
ExportVariable ExportVariable::operator()(	const String& _name
											) const
{
	ExportVariable tmp = deepcopy( *this );

	tmp.setName( _name );

	return tmp;
}
Benchmark::Benchmark(Benchmark& benchmark)
{
    expected_sat = NULL;
    setExpectedSat(benchmark.expected_sat);
    this->formulae.reserve(benchmark.formulae.size());
    for(int i=0 ; i<benchmark.formulae.size() ; i++)
    {
        this->formulae.push_back(deepcopy(benchmark.formulae[i]));
    }
}
Example #9
0
void test_copy(){
    x1_len = 3;
    x2_len = 3;
    w_len = 3;
    float V[3][3][3] = {{{10,10,10},{20,20,20},{30,30,30}},{{40,40,40},{50,50,50},{60,60,60}},{{70,70,70},{80,80,80},{90,90,90}}};
    float V_old[3][3][3] = {{{20,10,10},{20,20,20},{30,30,30}},{{40,40,40},{50,50,50},{60,60,60}},{{70,70,70},{80,80,80},{90,90,90}}};
    float ans;
    
    deepcopy(V, V_old);
    V[0][0][0] = 10000;
    printf("ans %f \n ",V_old[0][0][0]);
}
Example #10
0
File: tmpl.c Project: zhouqt/kbs
/* copy template from current board to some board, append it at the end
 * @board - the destination board
 * @pptemp - template array of destination board
 * @temp_size - array size
 * @pos - which template to copy, conf->pos
 * @return - 0 on success, -1 otherwise
 *
 * Warning: caller should check permission before this call.
 **/
int tmpl_copy_to_board(const char *board, struct a_template **pptemp, int *temp_size, int pos)
{
    if (!board || !pptemp || !*pptemp
            || !temp_size || *temp_size < 0 || *temp_size >= MAX_TEMPLATE
            || pos < 1 || pos > template_num)
        return -1;

    struct a_template *f = get_slot(&ptemplate, pos);
    struct a_template *t = get_slot(pptemp, *temp_size + 1);

    if (!deepcopy(t, board, f, currboard->filename)) {
        if (!orig_tmpl_save(*pptemp, *temp_size + 1, (char*)board)) {
            (*temp_size)++;
            return 0;
        }

        deepfree(t, board);
    }
    return -1;
}
Example #11
0
int
main() {
  char **p;
  Lexp l, newl;

  initpool();

  for (p = testcases; *p != NULL; p++) {
    printf("Lambda expression string \"%s\" -> ", *p);
    l = str2lexp(*p);
    printlexp(l);
    newl = deepcopy(l);
    printf("Original Lexp: ");
    printlexp(l);
    printf("Copied Lexp: ");
    printlexp(newl);
  }

  return 0;
}
void ParallelizerInternal::deepCopyMembers(std::map<SharedObjectNode*,SharedObject>& already_copied){
  FXInternal::deepCopyMembers(already_copied);
  funcs_ = deepcopy(funcs_,already_copied);
}
Example #13
0
 void QpToImplicit::deepCopyMembers(
     std::map<SharedObjectNode*, SharedObject>& already_copied) {
   ImplicitFunctionInternal::deepCopyMembers(already_copied);
   solver_ = deepcopy(solver_, already_copied);
 }
Example #14
0
returnValue CondensingExport::setupMultiplicationRoutines( )
{
	ExportVariable QQ = deepcopy( Q );
	QQ.setDataStruct( ACADO_LOCAL );

	ExportVariable QC1( "QC1",  getNX(),getNX() );
	ExportVariable QE1( "QE1",  getNX(),getNU()*getN() );
	ExportVariable Dx1( "Dx1",  getNX(),1 );
	ExportVariable QDx1("QDx1", getNX(),1 );
	ExportVariable Du1( "Du1",  getNU(),1 );
	ExportVariable RDu1("RDu1", getNU(),1 );
	ExportVariable Gx ( "Gx",   getNX(),getNX() );
	ExportVariable Gu ( "Gu",   getNX(),getNU() );
	ExportVariable C1 ( "C1",   getNX(),getNX() );
	ExportVariable E1 ( "E1",   getNX(),getNU()*getN() );
	ExportVariable d1 ( "d1",   getNX(),1 );
	ExportVariable u1 ( "u1",   getNU(),1 );
	ExportVariable C  ( "C",    getNX()*getN(),getNX() );
	ExportVariable QC ( "QC",   getNX()*getN(),getNX() );
	ExportVariable E  ( "E",    getNX()*getN(),getNU()*getN() );
	ExportVariable QE ( "QE",   getNX()*getN(),getNU()*getN() );
	ExportVariable QDx( "QDx",  getNX()*getN(),1 );
	ExportVariable g0 ( "g0",   getNX(),1 );
	ExportVariable g1 ( "g1",   getNU()*getN(),1 );
	ExportVariable H00( "H00",  getNX(),getNX() );
	ExportVariable H01( "H01",  getNX(),getNU()*getN() );
	ExportVariable H11( "H11",  getNU()*getN(),getNU()*getN() );

	multiplyQC1.setup( "multiplyQC1", QQ,C1,QC1 );
	multiplyQC1.addStatement( QC1 == QQ*C1 );

	multiplyQE1.setup( "multiplyQE1", QQ,E1,QE1 );
	multiplyQE1.addStatement( QE1 == QQ*E1 );

	multiplyQDX1.setup( "multiplyQDX1", QQ,Dx1,QDx1 );
	multiplyQDX1.addStatement( QDx1 == QQ*Dx1 );

	multiplyRDU1.setup( "multiplyRDU1", R,Du1,RDu1 );
	multiplyRDU1.addStatement( RDu1 == R*Du1 );

	multiplyQC2.setup( "multiplyQC2", QQF,C1,QC1 );
	multiplyQC2.addStatement( QC1 == QQF*C1 );

	multiplyQE2.setup( "multiplyQE2", QQF,E1,QE1 );
	multiplyQE2.addStatement( QE1 == QQF*E1 );

	multiplyQDX2.setup( "multiplyQDX2", QQF,Dx1,QDx1 );
	multiplyQDX2.addStatement( QDx1 == QQF*Dx1 );

	multiplyC.setup( "multiplyC", Gx,C1,C1("C1_new") );
	multiplyC.addStatement( C1("C1_new") == Gx*C1 );

	multiplyE.setup( "multiplyE", Gx,E1,E1("E1_new") );
	multiplyE.addStatement( E1("E1_new") == Gx*E1 );
	
	if ( performsSingleShooting() == BT_FALSE )
	{
		multiplyCD1.setup( "multiplyCD1", Gx,d1,d1("d1_new") );
		multiplyCD1.addStatement( d1("d1_new") == Gx*d1 );

		multiplyEU1.setup( "multiplyEU1", Gu,u1,d1("d1_new") );
		multiplyEU1.addStatement( d1("d1_new") += Gu*u1 );
	}

	if ( performsFullCondensing() == BT_FALSE )
	{
		multiplyG0.setup( "multiplyG0", C,QDx,g0 );
		multiplyG0.addStatement( g0 == (C^QDx) );
	}
	
	multiplyG1.setup( "multiplyG1", E,QDx,g1 );
	multiplyG1.addStatement( g1 == (E^QDx) );

	if ( performsFullCondensing() == BT_FALSE )
	{
		multiplyH00.setup( "multiplyH00", C,QC,H00 );
		multiplyH00.addStatement( H00 == (C^QC) );
	}

	multiplyH01.setup( "multiplyH01", C,QE,H01 );
	multiplyH01.addStatement( H01 == (C^QE) );

	multiplyH11.setup( "multiplyH11", E,QE,H11 );
	multiplyH11.addStatement( (H11 == (E^QE)) );

	return SUCCESSFUL_RETURN;
}
Example #15
0
 void FixedStepIntegrator::deepCopyMembers(
     std::map<SharedObjectNode*, SharedObject>& already_copied) {
   IntegratorInternal::deepCopyMembers(already_copied);
   F_ = deepcopy(F_, already_copied);
   G_ = deepcopy(G_, already_copied);
 }
Example #16
0
 void SimulatorInternal::deepCopyMembers(
     std::map<SharedObjectNode*, SharedObject>& already_copied) {
   FunctionInternal::deepCopyMembers(already_copied);
   integrator_ = deepcopy(integrator_, already_copied);
   output_fcn_ = deepcopy(output_fcn_, already_copied);
 }
Example #17
0
Lexp
Lcopy(Lexp orig) {
  return deepcopy(orig);
}
Example #18
0
File: main.c Project: robzidek/DCOC
int value_iteration(){
    
    //init stuff
    float stopping_criterion = 0.01;
    float *x1_space, *x2_space, ***V, ***V_old, *temp_w, *temp_u;
    int i,j,k;
    int x1_len = (x_max[0]-x_min[0])/step_size[0] + 1;
    int x2_len = (x_max[1]-x_min[1])/step_size[1] + 1;
    int w_len = sizeof(w_space)/sizeof(float);
    int u_len = sizeof(u_space)/sizeof(float);
    float x_new[] = {0,0};
    float g = 1;
    
    x1_space = (float *)(malloc(x1_len*sizeof(float)));
    for(i=0;i<x1_len;i++){
        x1_space[i] = x_min[0] + step_size[0]*i;
        //printf("%f ",x1_space[i]);
    }
    printf("\n");
    
    x2_space = (float *)(malloc(x2_len*sizeof(float)));
    for(i=0;i<x2_len;i++){
        x2_space[i] = x_min[1] + step_size[1]*i;
        //printf("%f ",x2_space[i]);
    }
    
    temp_w = (float *)(malloc(w_len*sizeof(float)));
    temp_u = (float *)(malloc(u_len*sizeof(float)));
    
    V = (float ***)(malloc(x1_len*sizeof(float *)));
    V_old = (float ***)(malloc(x1_len*sizeof(float *)));
    for(i=0;i<x1_len;i++){
        V[i] = (float **)(malloc(x2_len*sizeof(float *)));
        V_old[i] = (float **)(malloc(x2_len*sizeof(float *)));
        for(j=0;j<x2_len;j++){
            V[i][j]=(float *)(malloc(w_len*sizeof(float)));
            V_old[i][j]=(float *)(malloc(w_len*sizeof(float)));
            for(k=0;k<w_len;k++){
                V[i][j][k] = 0;
                V_old[i][j][k] = 1;
                
            }
        }
    }
    
    
    float a[] = {0,0};
    float x1=0.1,x2=0.1,w=0.1;
    pendulum_nonlinearmodel_ss(&a[0], 1, 0, del_t, &x_new[0]);
    printf("array gotten %f,%f\n",x_new[0],x_new[1]);
    
    float temp;
    temp= interpol(x1_space, x2_space, w_space, V, x1, x2, w,  x1_len, x2_len, w_len);
    printf("d %f",temp);
    //V_old = memcpy(&V[0][0][0], &V_old[0][0][0], x1_len*x2_len*w_len*sizeof(float));
    
    i = 0, j=0, k=0;
    int c = 0, d=0;
    float x_old[] = {0,0};
    float max_temp_u = 0;
    int iteration = 0;
    while(max_of_V(V, V_old, x1_len, x2_len, w_len) > stopping_criterion){
        deepcopy(V, V_old, x1_len, x2_len, w_len);
        //printf("cpy %f %f \n",V[1][1][1],V_old[1][1][1]);
        for(i=0;i<x1_len;i++){
            for(j=0;j<x2_len;j++){
                for(k=0;k<w_len;k++){
                    for(c=0;c<u_len;c++){
                        x_old[0] = x1_space[i];
                        x_old[1] = x2_space[j];
                        pendulum_nonlinearmodel_ss(&x_old[0], u_space[c], w_space[k], del_t, &x_new[0]);
                        //printf("non linear %f %f \n",x_new[0],x_new[1]);
                        temp_u[c] = g;
                        for(d=0;d<w_len;d++){
                            temp_w[d] = interpol(x1_space, x2_space, w_space, V, x_new[0], x_new[1], w_space[d],  x1_len, x2_len, w_len);
                            
                            temp_u[c] = temp_u[c] + temp_w[d]*prob_matrix[k][d];
                            //printf("temp w[d] %f\n",temp_w[d]);
                        }
                        
                        if(temp_u[c]>max_temp_u){
                            max_temp_u = temp_u[c];
                        }
                        
                    }
                    V[i][j][k] = max_temp_u;
                }
            }
        }
        printf("iteration %d value %f \n",iteration, max_of_V(V, V_old, x1_len, x2_len, w_len));
        
        iteration += 1;

    }
    
    
    


    
    
    printf("Value iteration Done\n");
    FILE *outfile;
    char *outfilename = "/Users/Rounak/Desktop/Summer project/DCOC/DCOC_in_C/DCOC_in_C/abc.csv";
    printf("%s",outfilename);
    if ((outfile = fopen(outfilename,"w")) == NULL)
    {
        printf("Error opening output file.\n");
        return -1;
    }
    else{
        printf("file opened\n");
    }
    for(i=0;i<x1_len;i++)
    {
        for(j=0;j<x2_len;j++)
        {
            for(k=0;k<w_len;k++){
                fprintf(outfile,"%f,",V[i][j][k]);
            }
            fprintf(outfile,"::::::");
        }
        fprintf(outfile,"\n");
    }
    fclose(outfile);
    
    return 0;
}
 void ImplicitFixedStepIntegratorInternal::deepCopyMembers(
     std::map<SharedObjectNode*, SharedObject>& already_copied) {
   FixedStepIntegratorInternal::deepCopyMembers(already_copied);
   implicit_solver_ = deepcopy(implicit_solver_, already_copied);
   backward_implicit_solver_ = deepcopy(backward_implicit_solver_, already_copied);
 }
Example #20
0
 void SDPSDQPInternal::deepCopyMembers(std::map<SharedObjectNode*, SharedObject>& already_copied) {
   SdqpSolverInternal::deepCopyMembers(already_copied);
   sdpsolver_ = deepcopy(sdpsolver_, already_copied);
   cholesky_ = deepcopy(cholesky_, already_copied);
   mapping_ = deepcopy(mapping_, already_copied);
 }
Example #21
0
//******************************************************* MAIN *******************************
int main(int argc, char* argv[]){
    //set up sdl
    SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);

    SDL_Window *Window = SDL_CreateWindow("Handmade Hero",
        SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED,
        640, 480, SDL_WINDOW_RESIZABLE);
    if(Window){
        SDL_Renderer *Renderer = SDL_CreateRenderer(Window, -1, 0);
    if(Renderer){

    // VIDEO
    sdl_offscreen_buffer Buffer = {}; // if non-initialized, declaring variables in a loop fails on SDLResizeTexture with a pointer error - im blaming the compiler
    sdl_window_dimension Dimension = SDLGetWindowDimension(Window);
    SDLResizeTexture(&Buffer, Renderer, Dimension.Width, Dimension.Height);
    keystates Keys = {};

    //AUDIO
    sdl_sound_output sound_output = sdl_sound_outputH(48000);
    //open audio
    SDLInitAudio(sound_output.SamplesPerSecond, sound_output.SamplesPerSecond * sound_output.BytesPerSample / 60);
    SDL_PauseAudio(0);

    //BW: state area allocation
    void *new_state_area = malloc(128*1024*1024);//need ~2 MB at least; give it 128 MiB -- 2MB for video; dont know audio
    void *prev_state_area = malloc(1024);// should be sizeof(state0), or sizeof(biggest statetype) later
    //apparently we didnt have enough memory, but only crashed sometimes? this fixed it
    void *state;
    
    {
        uint8 *next_ptr = (uint8*)prev_state_area;
        anim_comp *animation = (anim_comp*)next_ptr;
        next_ptr += sizeof(anim_comp);

        init_anim_comp(animation, 0,0);

        state0 *stateptr = (state0*)next_ptr;
        printf("state0 size %ld\n", sizeof(state0));
        uint64 stateptrn = (uint64)stateptr;
        uint64 sizeptr = (uint64)&(stateptr->size);
        uint64 deepc_ptr = (uint64)&(stateptr->deep_count);
        uint64 anim_ptr = (uint64)&(stateptr->animation);
        uint64 tsine_ptr = (uint64)&(stateptr->tSine);
        uint64 tvol_ptr = (uint64)&(stateptr->ToneVolume);
        uint64 thz_ptr = (uint64)&(stateptr->ToneHz);
        uint64 pu_ptr = (uint64)&(stateptr->pitch_up_was_pressed);
        printf("offset begin    %lu\n", sizeptr - stateptrn);
        printf("width of size   %lu\n", deepc_ptr - sizeptr);
        printf("width of deepc  %lu\n", anim_ptr - deepc_ptr);
        printf("width of animpt %lu\n", tsine_ptr - anim_ptr);
        printf("width of tsine  %lu\n", tvol_ptr - tsine_ptr);
        printf("width of tvol   %lu\n", thz_ptr - tvol_ptr);
        printf("width of thz    %lu\n", pu_ptr - thz_ptr);

        next_ptr += sizeof(state0);

        init_state0(stateptr, animation, 3000, 256, 0);

        state = stateptr;
        //return 0;
    }

    uint64 LastCounter = SDL_GetPerformanceCounter();
    uint64 LastCycleCount = _rdtsc();
    uint64 PerfCountFrequency = SDL_GetPerformanceFrequency();

    bool running = true;
    //main loop
    printf("enter main event loop\n");
    while(running){
        ///////NP_UPDATE/////////////
        //event capturing
        event_return events = eventHandler(&Keys);
        if(events.shouldQuit) running = false;
        //setup for p
        state_window_info Wi = {}; Wi.Height = Buffer.Height; Wi.Width = Buffer.Width; Wi.Pitch = Buffer.Pitch;
        int TargetQueueBytes = sound_output.LatencySampleCount * sound_output.BytesPerSample;
        state_sound_info Si = {}; Si.BytesToGet = TargetQueueBytes - SDL_GetQueuedAudioSize(1); Si.BytesPerSample = sound_output.BytesPerSample; Si.SamplesPerSecond = sound_output.SamplesPerSecond;
        uint64 state_size = 0;
        uint64 vbuffer_size = Buffer.Height * Buffer.Pitch;
        uint64 abuffer_size = Si.BytesToGet;
        state_return next;
        { //in case(statetype) or similar
            next = P_update_state0(*(state0*)state, new_state_area, Keys, Wi, Si);
            //p should return state_size? and also, what statetype we are in -> later
            state_size = sizeof(state0);
        }

        //GARBAGE COLLECTOR
        //move this state to previous state
        //fmemcpy(prev_state_area, new_state_area, state_size); //shallow copy, as supposed
        //printf("hi\n");
        deepcopy(prev_state_area, next.state, new_state_area, (uint8*)new_state_area + 128*1024*1024);
        //TODO(md): DEEPCPY

        //queue audio
        if (Si.BytesToGet > 0) SDL_QueueAudio(1, next.abuffer, abuffer_size);

        //render
        SDLUpdateWindow(Window, Renderer, Buffer, next.vbuffer);


        uint64 EndCycleCount = _rdtsc();
        uint64 EndCounter = SDL_GetPerformanceCounter();
        uint64 CounterElapsed = EndCounter - LastCounter;
        uint64 CyclesElapsed = EndCycleCount - LastCycleCount;

        real64 MSPerFrame = (((1000.0f * (real64)CounterElapsed) / (real64)PerfCountFrequency));
        real64 FPS = (real64)PerfCountFrequency / (real64)CounterElapsed;
        real64 MCPF = ((real64)CyclesElapsed / (1000.0f * 1000.0f));

        printf("%.02fms/f, %.02f/s, %.02fmc/f\n", MSPerFrame, FPS, MCPF);

        LastCycleCount = EndCycleCount;
        LastCounter = EndCounter;
    }
    } } //if(Renderer, Window)
    SDL_Quit();
    return 0;
}
Example #22
0
 void StabilizedQpToQp::deepCopyMembers(
     std::map<SharedObjectNode*, SharedObject>& already_copied) {
   StabilizedQpSolverInternal::deepCopyMembers(already_copied);
   qp_solver_ = deepcopy(qp_solver_, already_copied);
 }
Example #23
0
int value_iteration(){
    //float lol = prob_matrix1[0][0];
    //printf("%f",lol);
    //init stuff
    static 
    int i,j,k;
    
    
    float V[x1_len][x2_len][w_len];
    float V_old[x1_len][x2_len][w_len];
    
    float x_new[] = {0,0};
    float x_old[] = {1,0};
    float g = 1;
    
    float x1_space[x1_len];
    float x2_space[x2_len];
    
    float temp_w[w_len];
    float temp_u[u_len];
    
    int c = 0, d=0;
    
    int max_temp_c = 0;
    int iteration = 0;
    
    
    for(i=0;i<x1_len;i++){
        x1_space[i] = x_min[0] + step_size[0]*i;
        //printf("%f ",x1_space[i]);
    }
     
    
    for(i=0;i<x2_len;i++){
        x2_space[i] = x_min[1] + step_size[1]*i;
    }
    
    
   
    for(i=0;i<x1_len;i++){
        for(j=0;j<x2_len;j++){
            for(k=0;k<w_len;k++){
                V[i][j][k] = 1.5;
                V_old[i][j][k] = 1;
                
            }
        }
    }
    
    //DEBUG AREA
    //printf("%d x1_len \n",x1_len);
    //printf("%f probmatrix\n",prob_matrix[0][0]);
    //printf("%f sc\n",stopping_criterion);
    //printf("%f x\n",x_new[1]);
    //pendulum_nonlinearmodel_ss(x_old, u_space[c], w_space[k],x_new);
    //printf("%f x\n",x_new[1]);
    
    float debug;
    int deb;
    deb = find_nearest_neighbor(-0.1, 0.1, 0, 1);
    //printf("%d deb\n",deb);
    debug = interpol_3D(x1_space, x2_space, w_space, V, -0.2456,-0.8015, 0.1);//interpol might be off or V update
    
    printf("%f debug\n",debug);
   
    
    debug = max_of_V(V, V_old);
    
    
    
    
    while(max_of_V(V, V_old) > stopping_criterion){
        deepcopy(V, V_old);
        
        //printf("cpy %f %f \n",V[1][1][1],V_old[1][1][1]);
        for(i=0;i<x1_len;i++){
            for(j=0;j<x2_len;j++){
                for(k=0;k<w_len;k++){
                    max_temp_c = 0;
                    for(c=0;c<u_len;c++){
                        x_old[0] = x1_space[i];
                        x_old[1] = x2_space[j];
                        //printf("1 %f 2 %f 3 %f 4 %f\n", x1_space[i], x2_space[j],u_space[c], w_space[k]);
                        pendulum_nonlinearmodel_ss1(x_old, u_space[c], w_space[k],x_new);
                        //printf("non linear %f %f \n",x_new[0],x_new[1]);
                        temp_u[c] = g;
                        for(d=0;d<w_len;d++){
                            temp_w[d] = interpol_3D(x1_space, x2_space, w_space, V, x_new[0], x_new[1], w_space[d]);
                            //printf("%f temp_w[d]\n",temp_w[d]);
                            temp_u[c] = temp_u[c] + temp_w[d]*prob_matrix[k][d];
                            
                        }
                        //printf("temp u[c] %f\n",temp_u[c]);
                        if(temp_u[c]>temp_u[max_temp_c]){
                            max_temp_c = c;
                        }
                        
                    }
                    
                    V[i][j][k] = temp_u[max_temp_c];
                    //printf("V[i][j][k] %f \n",V[i][j][k]);
                    //printf("V_old[i][j][k] %f \n",V_old[i][j][k]);
                    //printf("================\n");
                }
            }
         
        }
     
        printf("iteration %d value %f \n",iteration, max_of_V(V, V_old));
        
        iteration += 1;

    }
    
    
    


    
    
    printf("Value iteration Done\n Writing to file...\n");
    int status;
    status = writeToFile(V);
    printf("Done\n");
    
    return(0);
}
Example #24
0
Signal& Signal::operator+=(const Signal& obj)
{
  deepcopy();
  return (*this) = (*this) + obj;
}
Example #25
0
Signal& Signal::operator*=(const double mag)
{
  deepcopy();
  return (*this) = (*this) * mag;
}
Example #26
0
void EvaluationMX::deepCopyMembers(
  std::map<SharedObjectNode*, SharedObject>& already_copied) {
  MXNode::deepCopyMembers(already_copied);
  fcn_ = deepcopy(fcn_, already_copied);
}
Example #27
0
 void Solve<Tr>::deepCopyMembers(std::map<SharedObjectNode*, SharedObject>& already_copied) {
   MXNode::deepCopyMembers(already_copied);
   linear_solver_ = deepcopy(linear_solver_, already_copied);
 }