Пример #1
0
void freeMcmcInternals(mcmcInternals *MCMCSettings)
{
    gsl_matrix_free(MCMCSettings->Sigma_beta);

    free(MCMCSettings);
}
Пример #2
0
int main (int argc, char *argv[]) {
    /* Local variables */
    int i, j, k, l; /* Indices and counters       */
    int nr;     /* Matrix dimensions, rows    */
    int nc;     /* Matrix dimensions, columns */
    int s;          /* Sign of the permutation    */

    if(argc==2) {


        /* Declare FILE variable */
        FILE* inputFile;

        /* Attempt to open file provided in cmdline arg */
        inputFile=fopen(argv[1],"r");

        if(inputFile==NULL) {

            /* Alert user file was not opened properly */
            fprintf(stdout,"\nFile was not opened properly\n");
            return 2;

        }

        /* Scan in nr and nc */
        fscanf(inputFile,"%d %d", &nr,&nc);

        /* Declare and allocate matrix and vector variables */
        gsl_matrix *A = gsl_matrix_calloc (nr,nc) ;      /* Coefficient Matrix        */
        gsl_vector *b = gsl_vector_calloc (nr) ;         /* Coefficient Vector        */
        gsl_vector *x = gsl_vector_calloc (nc);          /* Solution Vector           */
        gsl_permutation *p = gsl_permutation_alloc (nr); /* Permutation Vector  for LU */


        double a_data[nr*nc];
        double b_data[nr];

        for(i=0; i<nr; i++) {

            double coefValue;

            for(j=0; j<nc; j++) {
                // scan, add to a
                //index is i*j + j
                double matValue;
                fscanf(inputFile, " %lf ", &matValue);
                a_data[(i*j)+j]=matValue;
            }
            //scan, add to b
            //index is i

            fscanf(inputFile, " %lf ", &coefValue);
            b_data[i]=coefValue;
        }
        /*
               		double a_data[nr*nc];
        		a_data[0]=2.0;
        		a_data[1]=3.0;
        		a_data[2]=4.0;
        		a_data[3]=-6.0;

               		double b_data[nr];

        		b_data[0]=5.0;
        		b_data[1]=-3.0;
        */

        /* Initialize coefficient matrix (A) and vector (b) */
        k = 0 ;
        l = 0 ; /* set counters  to zero */

        for (i=0; i<nr; i++) {
            for (j=0; j<nc; j++) {
                gsl_matrix_set(A,i,j,a_data[k]) ;
                k++ ;
            } /* for j */
            gsl_vector_set(b,i,b_data[l]) ;
            l++ ;
        } /* for i */

        /* Print entries of A            */
        /* do not use gsl_matrix_fprintf */
        printf("Solution of the system Ax=b via PLU factorizations\n");
        printf("Matrix A:\n");
        for (i = 0; i < nr; i++) {
            for (j = 0; j < nc; j++)
                printf ("%7.2g ", gsl_matrix_get (A, i, j));
            putchar('\n');
        } /* for i */

        /* Print entries of vector b */
        printf("Vector b:\n");
        gsl_vector_fprintf (stdout, b,"%7.2g") ;

        /* Perform (inplace) PLU factorization:  overwrites A    */
        gsl_linalg_LU_decomp (A, p, &s); /* A is overwritten     */
        /* Now solve using the data in A and p found above and b */
        gsl_linalg_LU_solve (A, p, b, x); /* x returns retuls    */

        /* Print solution x */
        printf("Solution x:\n");
        gsl_vector_fprintf (stdout, x, "%7.2g");

        /* free up memory dynamically allocated */
        gsl_matrix_free (A);
        gsl_vector_free (b);
        gsl_permutation_free (p);
        gsl_vector_free (x);
    }
    return 0;
} /* main */
Пример #3
0
/* Populate field variables by SPR */
void _SnacRemesher_RecoverNode( void* _context, unsigned node_lI )
{
	Snac_Context*			context = (Snac_Context*)_context;
	Mesh*					mesh = context->mesh;
	MeshLayout*				layout = (MeshLayout*)mesh->layout;
	HexaMD*					decomp = (HexaMD*)layout->decomp;
	NodeLayout*				nLayout = layout->nodeLayout;

	Snac_Node*				node = Snac_Node_At( context, node_lI );
	Coord*					coord = Snac_NodeCoord_P( context, node_lI );
	Index 					nodeElementCount = context->mesh->nodeElementCountTbl[node_lI];
	Index 					nodeElement_I;
	Element_DomainIndex*	elements;
	gsl_matrix*				matA;
	gsl_vector* 			vecaStrain[6];
	gsl_vector*				vecaStress[6];
	gsl_vector*				vecaMaterial_I;
	gsl_vector*				vecaDensity;
	gsl_vector* 			vecbStrain[6];
	gsl_vector* 			vecbStress[6];
	gsl_vector* 			vecbMaterial_I;
	gsl_vector*				vecbDensity;
	Index 	 	 	 	 	i,j; 
	IJK						ijk;
	Node_GlobalIndex		node_gI = _MeshDecomp_Node_LocalToGlobal1D( decomp, node_lI );
	Node_GlobalIndex		gNodeI = decomp->nodeGlobal3DCounts[0];
	Node_GlobalIndex		gNodeJ = decomp->nodeGlobal3DCounts[1];
	Node_GlobalIndex		gNodeK = decomp->nodeGlobal3DCounts[2];
	Node_GlobalIndex		intNode_gI;
	Node_DomainIndex		intNode_lI;
	unsigned int			isBoundaryNode=0, patchCenterNum=1, patchCenterI, patchCenterList[2];

	RegularMeshUtils_Node_1DTo3D( decomp, node_gI, &ijk[0], &ijk[1], &ijk[2] );
	
	/* If boundary node, find a (topologically?) nearest interior node. 
	   Loosely following 
	       Khoei and Gharehbaghi, 2007, The superconvergent patch recovery techinique and data transfer operators in 3D plasticity problems,
	       Finite Elements in Analysis and Design 43 (2007) 630-- 648. */
	if( (gNodeI>2) && (ijk[0]==0) ) {
		ijk[0] += 1;
		isBoundaryNode = 1;
	}
	if( (gNodeI>2) && (ijk[0]==decomp->nodeGlobal3DCounts[0]-1) ) {
		ijk[0] -= 1;
		isBoundaryNode = 1;
	}
	if( (gNodeJ>2) && (ijk[1]==0) ) {
		ijk[1] += 1;
		isBoundaryNode = 1;
	}
	if( (gNodeJ>2) && (ijk[1]==decomp->nodeGlobal3DCounts[1]-1) ) {
		ijk[1] -= 1;
		isBoundaryNode = 1;
	}
	if( (gNodeK>2) && (ijk[2]==0) ) {
		ijk[2] += 1;
		isBoundaryNode = 1;
	}
	if( (gNodeK>2) && (ijk[2]==decomp->nodeGlobal3DCounts[2]-1) ) {
		ijk[2] -= 1;
		isBoundaryNode = 1;
	}

	/* node_lI itself always becomes a patch center,
	 and if the current node is a boundary node, find an interior node and add it to the patch center list. */
	patchCenterList[0] = node_lI; 
	if( isBoundaryNode ) {
		patchCenterNum=2;
		intNode_gI = ijk[0]+gNodeI*ijk[1]+gNodeI*gNodeJ*ijk[2];
		patchCenterList[1] = Mesh_NodeMapGlobalToLocal( mesh, intNode_gI );
	}

	/* initialize gsl vectors and matrix. */
	matA = gsl_matrix_alloc(4,4); gsl_matrix_set_zero( matA );
	vecaMaterial_I = gsl_vector_alloc(4); gsl_vector_set_zero( vecaMaterial_I );
	vecbMaterial_I = gsl_vector_alloc(4); gsl_vector_set_zero( vecbMaterial_I );
	vecaDensity = gsl_vector_alloc(4); gsl_vector_set_zero( vecaDensity );
	vecbDensity = gsl_vector_alloc(4); gsl_vector_set_zero( vecbDensity );
	for(i=0;i<6;i++) {
		vecaStrain[i] = gsl_vector_alloc(4); gsl_vector_set_zero( vecaStrain[i] );
		vecaStress[i] = gsl_vector_alloc(4); gsl_vector_set_zero( vecaStress[i] );
		vecbStrain[i] = gsl_vector_alloc(4); gsl_vector_set_zero( vecbStrain[i] );
		vecbStress[i] = gsl_vector_alloc(4); gsl_vector_set_zero( vecbStress[i] );
	}
	
	/* For each patch center */
	for( patchCenterI=0; patchCenterI < patchCenterNum; patchCenterI++ ) {
		/* For each incident element, find inicident tets. */
		for( nodeElement_I = 0; nodeElement_I < nodeElementCount; nodeElement_I++ ) {
			Element_DomainIndex		element_dI = context->mesh->nodeElementTbl[patchCenterList[patchCenterI]][nodeElement_I];

			if( element_dI < mesh->elementDomainCount ) {
				Index elementTetra_I;
				Snac_Element* element = Snac_Element_At( context, element_dI );

				/* Extract the element's node indices.  Note that there should always be eight of these. */
				{
					Element_GlobalIndex	element_gI;
					
					elements = Memory_Alloc_Array( Node_DomainIndex, nodeElementCount, "SnacRemesher" );
					element_gI = Mesh_ElementMapDomainToGlobal( mesh, element_dI );
					nLayout->buildElementNodes( nLayout, element_gI, elements );
				}
				
				/* Convert global node indices to domain. */
				{
					unsigned	eltNode_i;
					
					for( eltNode_i = 0; eltNode_i < nodeElementCount; eltNode_i++ ) {
						elements[eltNode_i] = Mesh_NodeMapGlobalToDomain( mesh, elements[eltNode_i] );
					}
				}

				/* For each incident tetrahedron in the incident element,
				   add up contributions to P, A, and b as in Zienkiewicz and Zhu (1992), p. 1336 */
				for( elementTetra_I = 0; elementTetra_I < Node_Element_Tetrahedra_Count;elementTetra_I++ ) {
					Tetrahedra_Index	tetra_I = NodeToTetra[nodeElement_I][elementTetra_I];
					Coord	tCrds[4];
					double 	positionP[4] = {1.0,0.0,0.0,0.0};
					Index 	ii,jj;

					/* Extract the tetrahedron's coordinates. */
					Vector_Set( tCrds[0], mesh->nodeCoord[elements[TetraToNode[tetra_I][0]]] );
					Vector_Set( tCrds[1], mesh->nodeCoord[elements[TetraToNode[tetra_I][1]]] );
					Vector_Set( tCrds[2], mesh->nodeCoord[elements[TetraToNode[tetra_I][2]]] );
					Vector_Set( tCrds[3], mesh->nodeCoord[elements[TetraToNode[tetra_I][3]]] );
					
					for(ii=1;ii<4;ii++)
						for(jj=0;jj<4;jj++)
							positionP[ii] += (0.25f * tCrds[jj][ii-1]);
					
					for(ii=0;ii<4;ii++) {
						double tmp;
						tmp = gsl_vector_get(vecbStrain[0],ii) + positionP[ii]*element->tetra[tetra_I].strain[0][0];
						gsl_vector_set(vecbStrain[0],ii,tmp);
						tmp = gsl_vector_get(vecbStrain[1],ii) + positionP[ii]*element->tetra[tetra_I].strain[1][1];
						gsl_vector_set(vecbStrain[1],ii,tmp);
						tmp = gsl_vector_get(vecbStrain[2],ii) + positionP[ii]*element->tetra[tetra_I].strain[2][2];
						gsl_vector_set(vecbStrain[2],ii,tmp);
						tmp = gsl_vector_get(vecbStrain[3],ii) + positionP[ii]*element->tetra[tetra_I].strain[0][1];
						gsl_vector_set(vecbStrain[3],ii,tmp);
						tmp = gsl_vector_get(vecbStrain[4],ii) + positionP[ii]*element->tetra[tetra_I].strain[0][2];
						gsl_vector_set(vecbStrain[4],ii,tmp);
						tmp = gsl_vector_get(vecbStrain[5],ii) + positionP[ii]*element->tetra[tetra_I].strain[1][2];
						gsl_vector_set(vecbStrain[5],ii,tmp);

						tmp = gsl_vector_get(vecbStress[0],ii) + positionP[ii]*element->tetra[tetra_I].stress[0][0];
						gsl_vector_set(vecbStress[0],ii,tmp);
						tmp = gsl_vector_get(vecbStress[1],ii) + positionP[ii]*element->tetra[tetra_I].stress[1][1];
						gsl_vector_set(vecbStress[1],ii,tmp);
						tmp = gsl_vector_get(vecbStress[2],ii) + positionP[ii]*element->tetra[tetra_I].stress[2][2];
						gsl_vector_set(vecbStress[2],ii,tmp);
						tmp = gsl_vector_get(vecbStress[3],ii) + positionP[ii]*element->tetra[tetra_I].stress[0][1];
						gsl_vector_set(vecbStress[3],ii,tmp);
						tmp = gsl_vector_get(vecbStress[4],ii) + positionP[ii]*element->tetra[tetra_I].stress[0][2];
						gsl_vector_set(vecbStress[4],ii,tmp);
						tmp = gsl_vector_get(vecbStress[5],ii) + positionP[ii]*element->tetra[tetra_I].stress[1][2];
						gsl_vector_set(vecbStress[5],ii,tmp);

/* 						tmp = gsl_vector_get(vecbMaterial_I,ii) + positionP[ii]*((double)(element->tetra[tetra_I].material_I)+0.5); */
						tmp = gsl_vector_get(vecbMaterial_I,ii) + positionP[ii]*pow(10.0,(double)(element->tetra[tetra_I].material_I));
						gsl_vector_set(vecbMaterial_I,ii,tmp); 

						tmp = gsl_vector_get(vecbDensity,ii) + positionP[ii]*element->tetra[tetra_I].density;
						gsl_vector_set(vecbDensity,ii,tmp); 
					
						for(jj=0;jj<4;jj++) {
							tmp = gsl_matrix_get(matA,ii,jj) + positionP[ii]*positionP[jj];
							gsl_matrix_set(matA,ii,jj,tmp);
						}
					} /* end of verteces of a tet. */
				} /* end of incident tets. */
			} /* if within my domain */
		} /* end of incident elements. */
	} /* end of patchCenterI */
		
	/* compute parameter vectors. */
	{
		int s;
		gsl_permutation * p = gsl_permutation_alloc (4);
     
		gsl_linalg_LU_decomp (matA, p, &s);
			
		for(i=0;i<6;i++) {
			gsl_linalg_LU_solve (matA, p, vecbStrain[i], vecaStrain[i]);
			gsl_linalg_LU_solve (matA, p, vecbStress[i], vecaStress[i]);
		}
		gsl_linalg_LU_solve (matA, p, vecbMaterial_I, vecaMaterial_I);
		gsl_linalg_LU_solve (matA, p, vecbDensity, vecaDensity);
		/* 			printf ("x = \n"); */
		/* 			gsl_vector_fprintf (stdout, x, "%g"); */
		gsl_permutation_free (p);
	}	

	/* zero the arrays to store recovered field. */
	/* probably not necessary. */
	/* 		for(i=0;i<6;i++) { */
	/* 			node->strainSPR[i] = 0.0f; */
	/* 			node->stressSPR[i] = 0.0f; */
	/* 		} */

	/* Recover using the parameter vectors. */
	for(j=0;j<6;j++) {
		node->strainSPR[j] = gsl_vector_get(vecaStrain[j],0);
		node->stressSPR[j] = gsl_vector_get(vecaStress[j],0);
		for(i=0;i<3;i++) {
			node->strainSPR[j] += gsl_vector_get(vecaStrain[j],i+1)*(*coord)[i];
			node->stressSPR[j] += gsl_vector_get(vecaStress[j],i+1)*(*coord)[i];
		}
	}

	node->material_ISPR = gsl_vector_get(vecaMaterial_I,0);
	for(i=0;i<3;i++) 
		node->material_ISPR += gsl_vector_get(vecaMaterial_I,i+1)*(*coord)[i];

	node->densitySPR = gsl_vector_get(vecaDensity,0);
	for(i=0;i<3;i++) 
		node->densitySPR += gsl_vector_get(vecaDensity,i+1)*(*coord)[i];

	/* free gsl vectors and matrix. */
	gsl_matrix_free( matA );
	gsl_vector_free( vecaMaterial_I );
	gsl_vector_free( vecbMaterial_I );
	gsl_vector_free( vecaDensity );
	gsl_vector_free( vecbDensity );
	for(i=0;i<6;i++) {
		gsl_vector_free( vecaStrain[i] );
		gsl_vector_free( vecaStress[i] );
		gsl_vector_free( vecbStrain[i] );
		gsl_vector_free( vecbStress[i] );
	}

	/* Free the element node array. */
	FreeArray( elements );

	/* end of recovery. */
}
Пример #4
0
static int
hybrid_alloc (void *vstate, size_t n)
{
  hybrid_state_t *state = (hybrid_state_t *) vstate;
  gsl_matrix *J, *q, *r;
  gsl_vector *tau, *diag, *qtf, *newton, *gradient, *x_trial, *f_trial,
   *df, *qtdf, *rdx, *w, *v;

  J = gsl_matrix_calloc (n, n);

  if (J == 0)
    {
      GSL_ERROR_VAL ("failed to allocate space for J", GSL_ENOMEM, 0);
    }

  state->J = J;

  q = gsl_matrix_calloc (n, n);

  if (q == 0)
    {
      gsl_matrix_free (J);

      GSL_ERROR_VAL ("failed to allocate space for q", GSL_ENOMEM, 0);
    }

  state->q = q;

  r = gsl_matrix_calloc (n, n);

  if (r == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);

      GSL_ERROR_VAL ("failed to allocate space for r", GSL_ENOMEM, 0);
    }

  state->r = r;

  tau = gsl_vector_calloc (n);

  if (tau == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);

      GSL_ERROR_VAL ("failed to allocate space for tau", GSL_ENOMEM, 0);
    }

  state->tau = tau;

  diag = gsl_vector_calloc (n);

  if (diag == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);

      GSL_ERROR_VAL ("failed to allocate space for diag", GSL_ENOMEM, 0);
    }

  state->diag = diag;

  qtf = gsl_vector_calloc (n);

  if (qtf == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);

      GSL_ERROR_VAL ("failed to allocate space for qtf", GSL_ENOMEM, 0);
    }

  state->qtf = qtf;

  newton = gsl_vector_calloc (n);

  if (newton == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);

      GSL_ERROR_VAL ("failed to allocate space for newton", GSL_ENOMEM, 0);
    }

  state->newton = newton;

  gradient = gsl_vector_calloc (n);

  if (gradient == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);

      GSL_ERROR_VAL ("failed to allocate space for gradient", GSL_ENOMEM, 0);
    }

  state->gradient = gradient;

  x_trial = gsl_vector_calloc (n);

  if (x_trial == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);

      GSL_ERROR_VAL ("failed to allocate space for x_trial", GSL_ENOMEM, 0);
    }

  state->x_trial = x_trial;

  f_trial = gsl_vector_calloc (n);

  if (f_trial == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);

      GSL_ERROR_VAL ("failed to allocate space for f_trial", GSL_ENOMEM, 0);
    }

  state->f_trial = f_trial;

  df = gsl_vector_calloc (n);

  if (df == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);

      GSL_ERROR_VAL ("failed to allocate space for df", GSL_ENOMEM, 0);
    }

  state->df = df;

  qtdf = gsl_vector_calloc (n);

  if (qtdf == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);

      GSL_ERROR_VAL ("failed to allocate space for qtdf", GSL_ENOMEM, 0);
    }

  state->qtdf = qtdf;


  rdx = gsl_vector_calloc (n);

  if (rdx == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);
      gsl_vector_free (qtdf);

      GSL_ERROR_VAL ("failed to allocate space for rdx", GSL_ENOMEM, 0);
    }

  state->rdx = rdx;

  w = gsl_vector_calloc (n);

  if (w == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);
      gsl_vector_free (qtdf);
      gsl_vector_free (rdx);

      GSL_ERROR_VAL ("failed to allocate space for w", GSL_ENOMEM, 0);
    }

  state->w = w;

  v = gsl_vector_calloc (n);

  if (v == 0)
    {
      gsl_matrix_free (J);
      gsl_matrix_free (q);
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);
      gsl_vector_free (qtdf);
      gsl_vector_free (rdx);
      gsl_vector_free (w);

      GSL_ERROR_VAL ("failed to allocate space for v", GSL_ENOMEM, 0);
    }

  state->v = v;

  return GSL_SUCCESS;
}
Пример #5
0
int w_update(
  gsl_matrix *weights,
  gsl_matrix *x_white,
  gsl_matrix *bias,
  gsl_matrix *shuffled_x_white, //work space for shuffled x_white
  gsl_permutation *p, // random permutation
  gsl_rng *r, // random stream from gsl
  double lrate){

  int error = 0;
  size_t i;
  const size_t NVOX = x_white->size2;
  const size_t NCOMP = x_white->size1;
  size_t block = (size_t)floor(sqrt(NVOX/3.0));
  gsl_matrix *ib = gsl_matrix_alloc(1,block);
  gsl_matrix_set_all( ib, 1.0);

  gsl_ran_shuffle (r, p->data, NVOX, sizeof(size_t));
  // gsl_matrix *shuffled_x_white = gsl_matrix_alloc(NCOMP,NVOX);
  // gsl_matrix_memcpy(shuffled_x_white, x_white);
  gsl_vector_view arow;
  #pragma omp parallel for private(i,arow)
  for (i = 0; i < x_white->size1; i++) {
    arow = gsl_matrix_row(shuffled_x_white,i);
    gsl_permute_vector (p, &arow.vector);

  }

  size_t start;
  gsl_matrix *unmixed     = gsl_matrix_alloc(NCOMP,block);
  gsl_matrix *unm_logit   = gsl_matrix_alloc(NCOMP,block);
  gsl_matrix *temp_I      = gsl_matrix_alloc(NCOMP,NCOMP);
  gsl_matrix *ones        = gsl_matrix_alloc(block,1);
  gsl_matrix_set_all(ones, 1.0);
  double max;
  gsl_matrix_view sub_x_white_view;
  // gsl_matrix *d_unmixer = gsl_matrix_alloc(NCOMP,NCOMP);
  for (start = 0; start < NVOX; start = start + block) {
    if (start + block > NVOX-1){
      block = NVOX-start;
      gsl_matrix_free(ib);
      ib = gsl_matrix_alloc(1,block);
      gsl_matrix_set_all( ib, 1.0);
      gsl_matrix_free(unmixed);
      unmixed = gsl_matrix_alloc(NCOMP,block);
      gsl_matrix_free(unm_logit);
      unm_logit = gsl_matrix_alloc(NCOMP,block);
      gsl_matrix_free(ones);
      ones = gsl_matrix_alloc(block,1);
      gsl_matrix_set_all(ones, 1.0);

      }
    // sub_x_white = xwhite[:, permute[start:start+block]]
    sub_x_white_view = gsl_matrix_submatrix(shuffled_x_white, 0,start, NCOMP, block );
    // Compute unmixed = weights . sub_x_white + bias . ib
    matrix_mmul(weights, &sub_x_white_view.matrix, unmixed);
    gsl_blas_dgemm(CblasNoTrans, CblasNoTrans,
      1.0, bias, ib, 1.0, unmixed);
    // Compute 1-2*logit
    gsl_matrix_memcpy(unm_logit, unmixed);
    matrix_apply_all(unm_logit, logit);
    // weights = weights + lrate*(block*I+(unm_logit*unmixed.T))*weights
    gsl_matrix_set_identity(temp_I); // temp_I = I
    // (1) temp_I = block*temp_I +unm_logit*unmixed.T
    gsl_blas_dgemm( CblasNoTrans,CblasTrans,
                    1.0, unm_logit, unmixed,
                    (double)block , temp_I);
    // BE CAREFUL with aliasing here! use d_unmixer if problems arise
    // gsl_matrix_memcpy(d_unmixer, weights);
    // (2) weights = weights + lrate*temp_I*weights
    gsl_blas_dgemm( CblasNoTrans,CblasNoTrans,
                    lrate, temp_I, weights,
                    1.0, weights);
    // Update the bias
    gsl_blas_dgemm( CblasNoTrans, CblasNoTrans,
                    lrate, unm_logit, ones,
                    1.0,  bias);
    // check if blows up
    max = gsl_matrix_max(weights);
    if (max > MAX_W){

      if (lrate<1e-6) {
        printf("\nERROR: Weight matrix may not be invertible\n");
        error = 2;
        break;
      }
      error = 1;
      break;
    }

  }
  // set number of threads back to normal
  // openblas_set_num _threads(MAX_THREAD);

  //clean up
  // gsl_rng_free (r);
  // gsl_permutation_free (p);
  // gsl_matrix_free(d_unmixer);
  gsl_matrix_free(ib);
  gsl_matrix_free(unmixed);
  gsl_matrix_free(temp_I);
  gsl_matrix_free(ones);
  gsl_matrix_free(unm_logit);
  // gsl_matrix_free(shuffled_x_white);
  return(error);

}
Пример #6
0
int main(int argc, char **argv)
{
  gsl_matrix *Original;
  gsl_matrix *Mtr_Cov;


  FILE *input;
  int num_lineas;
  int i,j,k;
  double var;

/*---------------------------------------------------------
Verifica cuales archivos fueron usados como input y se asegura de que solo haya cargado uno.
-----------------------------------------------------------*/
  printf("Este programa se ejecutó con %d argumento(s):\n",argc-1);
  for(i=1;i<argc;i++){
    printf("%s\n", argv[i]);
  }
  if(argc!=2){
    printf("se necesita 1 argumento además del nombre del ejecutable!,\n  EXIT!\n");
    exit(1);
    }
    else{
      printf("El archivo a usar es %s\n", argv[1]);

    }
//--------------------------------------------------------
    input=fopen(argv[1],"r");
    if(!input){
      printf("surgió un problema abriendo el archivo\n");
      exit(1);
    }
/*---------------------------------------------------------
toma como archivo base el primer argumento y cuenta sus lineas
-----------------------------------------------------------*/
    num_lineas=0;
    while ((var = fgetc(input)) != EOF){
      if (var =='\n')
	++num_lineas;
    }

    //printf("Número de lineas del archivo:\n -->%d\n",num_lineas); 

/*---------------------------------------------------------
Data allocation
-----------------------------------------------------------*/ 
    rewind(input);
    Original=gsl_matrix_alloc((num_lineas),24);
    // printf("\nOriginal\n");
    gsl_matrix_fscanf(input,Original);
    //gsl_matrix_fprintf (stdout, Original, "%g");
    //CheckPoint
    //printf("matriz escaneada\n");
/*---------------------------------------------------------
Promedio
-----------------------------------------------------------*/ 
    float *prom;
    int y;
    
    prom=malloc((num_lineas) * sizeof(float));
    //printf("...\n");
    for(k=0;k<num_lineas;k++){
      float suma=0.0;
      for(y=0;y<24;y++){
	suma+=gsl_matrix_get(Original,k,y);
      }
      prom[k]=suma/24.0;
    }
    printf("Checkpoint... Promedios\n");

/*---------------------------------------------------------
Efectos en la matriz
-----------------------------------------------------------*/ 
    Mtr_Cov=gsl_matrix_alloc(num_lineas,num_lineas);
    //printf("...\n");
    int l,n,m;
    double sprite=0;
    for(l=0;l<num_lineas;l++){
      for(m=0;m<num_lineas;m++){
	for(n=1;n<24;n++){
	  double flan=gsl_matrix_get(Original,m,n);
	  double agua=prom[m];
	  double frutino=gsl_matrix_get(Original,l,n);
	  double tang=prom[l];
	  double jarra1=(flan-agua);
	  double jarra2=(frutino-tang);
	  //printf("%g  %g\n",jarra1,jarra2);
	  sprite=sprite+(jarra1*jarra2)/24;
	}
	
	gsl_matrix_set(Mtr_Cov,m,l,sprite);
	sprite=0;
      }}
    
/*---------------------------------------------------------
Matriz de covarianza creada;
sacar vectores y valores propios de la matriz.
-----------------------------------------------------------*/
/*
    int pa,po;
    double can;
    for(pa=0;pa<num_lineas;pa++){
      for(po=0;po<num_lineas;po++){
	can=gsl_matrix_get(Mtr_Cov,po,pa);
	printf("%f ",can);
      }
      printf("\n");
    }
*/




    gsl_eigen_symmv_workspace * w = gsl_eigen_symmv_alloc (num_lineas);
    gsl_vector *eval = gsl_vector_alloc (num_lineas);
    gsl_matrix *evec = gsl_matrix_alloc (num_lineas,num_lineas);
  
    gsl_eigen_symmv (Mtr_Cov, eval, evec, w);   
    gsl_eigen_symmv_sort (eval, evec,GSL_EIGEN_SORT_ABS_ASC);
/*---------------------------------------------------------
PON ESA COSA HORROROSA AHI O VERAS!!!
-----------------------------------------------------------*/
    FILE *Out1;
    FILE *Out2;
    
    Out1 = fopen("JorgeHayek_eigenvalues.dat", "w");
    Out2 = fopen("JorgeHayek_eigenvectors.dat", "w");
    
    fprintf(Out1,"EigenValues:\n");
    fprintf(Out2,"EigenVectors:\n");



    for (i = 0; i < num_lineas; i++)
      {
	double eval_i  = gsl_vector_get (eval, i);

	fprintf (Out1,"%g\n", eval_i);
      }

     for (i = 0; i < 11; i++)
      {fprintf(Out2,"--------------------------------------------\nVector %d\n--------------------------------------------\n",i);
	gsl_vector_view evec_i 
	  = gsl_matrix_column (evec, i);

	gsl_vector_fprintf (Out2, 
			    &evec_i.vector, "%g");
	 
      }
     
  





/*---------------------------------------------------------
FIN
-----------------------------------------------------------*/  
    gsl_vector_free (eval);
    gsl_matrix_free (evec);
    gsl_matrix_free(Original);
    fclose(input);
    return 0;
}
Пример #7
0
int DPMHC_xi_smplr(struct str_DPMHC *ptr_DPMHC_data, int i_J, struct str_firm_data *a_firm_data)
{
    int j,i;
    int i_K = ptr_DPMHC_data->i_K;
    int i_n = ptr_DPMHC_data->v_y->size; // is this the same as i_J???
    if (i_n != i_J){
        fprintf(stderr,"Error in  DPMN_xi_smplr(): DPMHC.v_y length does not equal i_J\n");
        exit(1);
    }
    double d_sumT_si;

    gsl_vector_int *vi_S = ptr_DPMHC_data->vi_S;
    gsl_matrix *m_theta = ptr_DPMHC_data->m_DPtheta;
    double d_A = ptr_DPMHC_data->d_A;
    double d_mu_si, d_tau_si, d_ei;
    double d_mean_j, d_var_j;
    double d_xi_j;

    int i_Ti;
    int i_factors = (a_firm_data[0].v_beta)->size;
    gsl_vector *v_ret;
    gsl_matrix *m_factors;
    gsl_vector *v_betai;
    gsl_vector *v_rstar_i;
    gsl_matrix *m_Xi;
    gsl_matrix_view mv_Xi;
    double d_rstar_j;
    double d_s2i;


    for(j=0;j<i_K;j++){

        d_mu_si = mget(m_theta,j,0);
        d_tau_si = mget(m_theta,j,2);


        d_rstar_j = 0.;
        d_sumT_si = 0;
        for(i=0;i<i_J;i++){
            if( vget_int(vi_S,i) == j ){

                d_ei = vget(ptr_DPMHC_data->v_e,i);

                m_factors = a_firm_data[i].m_factors;
                i_Ti = a_firm_data[i].i_ni;
                d_s2i = a_firm_data[i].d_s2;
                m_Xi = gsl_matrix_alloc(i_Ti,i_factors);
                mv_Xi = gsl_matrix_submatrix(m_factors,0,0,i_Ti,i_factors);
                gsl_matrix_memcpy(m_Xi,&mv_Xi.matrix);

                v_betai = a_firm_data[i].v_beta;
                v_ret = a_firm_data[i].v_ret;
                v_rstar_i = gsl_vector_alloc(i_Ti);
                gsl_vector_memcpy(v_rstar_i,v_ret);
                gsl_blas_dgemv(CblasNoTrans, -1.0, m_Xi, v_betai, 1.0, v_rstar_i);

                gsl_vector_add_constant(v_rstar_i, -d_mu_si);
                gsl_vector_scale(v_rstar_i, 1./(sqrt(d_tau_si) * d_ei) );

                d_rstar_j += sum(v_rstar_i);

                d_sumT_si += i_Ti/(d_s2i/(d_tau_si * d_ei * d_ei) );

                gsl_matrix_free(m_Xi);
                gsl_vector_free(v_rstar_i);
            }
        }

        d_var_j = 1./( 1./(d_A * d_A) + d_sumT_si);
        d_mean_j = d_rstar_j * d_var_j;

        d_xi_j = d_mean_j + gsl_ran_gaussian_ziggurat(rng, sqrt(d_var_j) );

        mset(m_theta, j, 1, d_xi_j);

       // printf("%d: eta = %g lambda^2 = %g\n",j, mget(m_theta,j,0), mget(m_theta,j,1) );
     }


    return 0;
}
Пример #8
0
void Spectrometer::countAmplitudes_bulk_B(Medium &Osrodek, QString DataName, QProgressBar *Progress, QTextBrowser *Browser, double kx, double ky, double w, int polarisation, double x_lenght, double y_lenght, double precision) {

    double a=Osrodek.itsBasis.getLatticeConstant();

    int RecVec=itsRecVectors;

    int dimension=3*(2*RecVec+1)*(2*RecVec+1);

    std::ofstream plik;
    DataName="results/amplitudes/"+ DataName + ".dat";
    QByteArray   bytes  = DataName.toAscii();
    const char * CDataName = bytes.data();
    plik.open(CDataName);

    //inicjalizacje wektorów i macierzy
    gsl_matrix *gamma=gsl_matrix_calloc(dimension, dimension);
    gsl_matrix *V=gsl_matrix_calloc(dimension, dimension);
    gsl_vector *S=gsl_vector_calloc(dimension);
    gsl_vector *work=gsl_vector_calloc(dimension);


    //gamma dla Podłoża
    /*
    S - numeruje transformaty tensora sprężystoœci i gestosci
    i - numeruje wiersze macierzy
    j - numeruje kolumny macierzy
    */
    for(int Nx=-RecVec, i=0, S=0; Nx<=RecVec; Nx++) {
        for(int Ny=-RecVec; Ny<=RecVec; Ny++, i=i+3) {
            for(int Nx_prim=-RecVec, j=0; Nx_prim<=RecVec; Nx_prim++) {
                for(int Ny_prim=-RecVec; Ny_prim<=RecVec; Ny_prim++, j=j+3, S++) {

                    double Elasticity[6][6];
                    itsRecBasisSubstance[S].getElasticity(Elasticity);
                    double Density=itsRecBasisSubstance[S].getDensity();
                    double gx=2*M_PI*Nx/a;
                    double gy=2*M_PI*Ny/a;
                    double gx_prim=2*M_PI*Nx_prim/a;
                    double gy_prim=2*M_PI*Ny_prim/a;

                    gsl_matrix_set(gamma, i, j, Elasticity[0][0]*(kx+gx)*(kx+gx_prim)+Elasticity[3][3]*(ky+gy)*(ky+gy_prim)-Density*w*w);
                    gsl_matrix_set(gamma, i+1, j, Elasticity[0][1]*(kx+gx_prim)*(ky+gy)+Elasticity[3][3]*(ky+gy_prim)*(kx+gx));
                    gsl_matrix_set(gamma, i, j+1, Elasticity[0][1]*(ky+gy_prim)*(kx+gx)+Elasticity[3][3]*(kx+gx_prim)*(ky+gy));
                    gsl_matrix_set(gamma, i+1, j+1, Elasticity[0][0]*(ky+gy_prim)*(ky+gy)+Elasticity[3][3]*(kx+gx_prim)*(kx+gx)-Density*w*w);
                    gsl_matrix_set(gamma, i+2, j+2, Elasticity[3][3]*(ky+gy_prim)*(ky+gy)+Elasticity[3][3]*(kx+gx_prim)*(kx+gx)-Density*w*w);

                }
            }
        }
    }

    //rozwiązanie układu równań
    gsl_linalg_SV_decomp(gamma, V, S, work);

    gsl_complex u;
    double Gx, Gy;

    if (polarisation==3) {

        gsl_complex ux, uy, uz;

        for(double x=0; x < x_lenght; x=x+precision) {
            for(double y=0; y < y_lenght; y=y+precision) {
                ux = gsl_complex_rect(0, 0);
                uy = gsl_complex_rect(0, 0);
                uz = gsl_complex_rect(0, 0);

                //pasek postepu
                int postep=int(100*x/x_lenght);
                Progress->setValue(postep);
                Progress->update();
                QApplication::processEvents();

                for (int Nx=-RecVec, i=0; Nx <= RecVec; Nx++) {
                    for (int Ny=-RecVec; Ny <= RecVec; Ny++, i=i+3) {

                        Gx=2*M_PI*Nx/a;
                        Gy=2*M_PI*Ny/a;

                        double Ax = gsl_matrix_get(V, i, dimension-1);
                        double Ay = gsl_matrix_get(V, i+1, dimension-1);
                        double Az = gsl_matrix_get(V, i+2, dimension-1);

                        gsl_complex expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
                        gsl_complex exp1 = gsl_complex_exp(expin1);

                        gsl_complex multiply = gsl_complex_mul_real(exp1, Ax);
                        ux = gsl_complex_add(ux, multiply);

                        expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
                        exp1 = gsl_complex_exp(expin1);

                        multiply = gsl_complex_mul_real(exp1, Ay);
                        uy = gsl_complex_add(uy, multiply);

                        expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
                        exp1 = gsl_complex_exp(expin1);

                        multiply = gsl_complex_mul_real(exp1, Az);
                        uz = gsl_complex_add(uz, multiply);
                    }
                }

                double U = sqrt(gsl_complex_abs(ux)*gsl_complex_abs(ux)+gsl_complex_abs(uy)*gsl_complex_abs(uy)+gsl_complex_abs(uz)*gsl_complex_abs(uz));

                //zapisanie wartości do pliku
                QString nazwa = Osrodek.itsBasis.getFillingSubstance().getName();
                if(nazwa=="Air")
                {
                    double rad=Osrodek.itsBasis.getRadius();
                    if(sqrt(x*x+y*y) > rad && sqrt((a-x)*(a-x)+y*y) > rad && sqrt((a-x)*(a-x)+(a-y)*(a-y)) > rad && sqrt((a-y)*(a-y)+x*x) > rad)
                    {
                        plik << x << "\t" << y << "\t" << U << "\n";
                    }
                } else {
                    plik << x << "\t" << y << "\t" << U << "\n";
                }

            }



            plik << "\n";
        }

    } else if (polarisation==4) {

            gsl_complex uxx, uxy, uxz, uyx, uyy, uyz, uzx, uzy, uzz;
            double Uxx, Uxy, Uxz, Uyx, Uyy, Uyz, Uzx, Uzy, Uzz;

            for(double x=0; x < x_lenght; x=x+precision) {
                for(double y=0; y < y_lenght; y=y+precision) {

                    uxx = gsl_complex_rect(0, 0);
                    uxy = gsl_complex_rect(0, 0);
                    uxz = gsl_complex_rect(0, 0);
                    uyx = gsl_complex_rect(0, 0);
                    uyy = gsl_complex_rect(0, 0);
                    uyz = gsl_complex_rect(0, 0);
                    uzx = gsl_complex_rect(0, 0);
                    uzy = gsl_complex_rect(0, 0);
                    uzz = gsl_complex_rect(0, 0);

                    double rad=Osrodek.itsBasis.getRadius();
                    double Ela[6][6];
                    if(sqrt(x*x+y*y) > rad && sqrt((a-x)*(a-x)+y*y) > rad && sqrt((a-x)*(a-x)+(a-y)*(a-y)) > rad && sqrt((a-y)*(a-y)+x*x) > rad)
                    {
                        Osrodek.itsBasis.getSubstance().getElasticity(Ela);
                    } else {
                        Osrodek.itsBasis.getFillingSubstance().getElasticity(Ela);
                    }

                    //pasek postepu
                    int postep=int(100*x/x_lenght);
                    Progress->setValue(postep);
                    Progress->update();
                    QApplication::processEvents();

                    for (int Nx=-RecVec, i=0; Nx <= RecVec; Nx++) {
                        for (int Ny=-RecVec; Ny <= RecVec; Ny++, i=i+3) {

                            Gx=2*M_PI*Nx/a;
                            Gy=2*M_PI*Ny/a;

                            double Ax = gsl_matrix_get(V, i, dimension-1);
                            double Ay = gsl_matrix_get(V, i+1, dimension-1);
                            double Az = gsl_matrix_get(V, i+2, dimension-1);

                            gsl_complex expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
                            gsl_complex exp1 = gsl_complex_exp(expin1);

                            gsl_complex multiply = gsl_complex_mul_real(exp1, Ax);

                            //uxx
                            gsl_complex multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), kx+Gx));
                            uxx = gsl_complex_add(uxx, multidiff);

                            //uxy
                            multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), ky+Gy));
                            uxy = gsl_complex_add(uxy, multidiff);


                            expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
                            exp1 = gsl_complex_exp(expin1);

                            //uy
                            multiply = gsl_complex_mul_real(exp1, Ay);

                            //uyx
                            multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), kx+Gx));
                            uyx = gsl_complex_add(uyx, multidiff);

                            //uyy
                            multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), ky+Gy));
                            uyy = gsl_complex_add(uyy, multidiff);

                            expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
                            exp1 = gsl_complex_exp(expin1);

                            multiply = gsl_complex_mul_real(exp1, Az);

                            //uzx
                            multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), kx+Gx));
                            uzx = gsl_complex_add(uzx, multidiff);

                            //uzy
                            multidiff = gsl_complex_mul(multiply, gsl_complex_mul_real(gsl_complex_rect(0,1), ky+Gy));
                            uzy = gsl_complex_add(uzy, multidiff);
                        }
                    }

                    Uxx=gsl_complex_abs(uxx);
                    Uxy=gsl_complex_abs(uxy);
                    Uxz=gsl_complex_abs(uxz);
                    Uyx=gsl_complex_abs(uyx);
                    Uyy=gsl_complex_abs(uyy);
                    Uyz=gsl_complex_abs(uyz);
                    Uzx=gsl_complex_abs(uzx);
                    Uzy=gsl_complex_abs(uzy);
                    Uzz=gsl_complex_abs(uzz);

                    double U = Ela[0][0]*(Uxx*Uxx+Uyy*Uyy+Uzz*Uzz)+2*Ela[0][1]*(Uxx*Uyy+Uxx*Uzz+Uyy*Uzz)+0.25*Ela[3][3]*((Uyz+Uzy)*(Uyz+Uzy)+(Uxz+Uzx)*(Uxz+Uzx)+(Uxy+Uyx)*(Uxy+Uyx));

                    //zapisanie wartości do pliku
                    QString nazwa = Osrodek.itsBasis.getFillingSubstance().getName();
                    if(nazwa=="Air")
                    {
                        double rad=Osrodek.itsBasis.getRadius();
                        if(sqrt(x*x+y*y) > rad && sqrt((a-x)*(a-x)+y*y) > rad && sqrt((a-x)*(a-x)+(a-y)*(a-y)) > rad && sqrt((a-y)*(a-y)+x*x) > rad)
                        {
                            plik << x << "\t" << y << "\t" << U << "\n";
                        }
                    } else {
                        plik << x << "\t" << y << "\t" << U << "\n";
                    }

                }



                plik << "\n";
            }


    } else {

        for(double x=0; x < x_lenght; x=x+precision) {
            for(double y=0; y < y_lenght; y=y+precision) {
                u = gsl_complex_rect(0, 0);

                //pasek postepu
                int postep=int(100*x/x_lenght);
                Progress->setValue(postep);
                Progress->update();
                QApplication::processEvents();

                for (int Nx=-RecVec, i=0; Nx <= RecVec; Nx++) {
                    for (int Ny=-RecVec; Ny <= RecVec; Ny++, i=i+3) {

                        Gx=2*M_PI*Nx/a;
                        Gy=2*M_PI*Ny/a;

                        double A = gsl_matrix_get(V, i+polarisation, dimension-1);

                        gsl_complex expin1 = gsl_complex_rect(0, (kx+Gx)*x+(ky+Gy)*y);
                        gsl_complex exp1 = gsl_complex_exp(expin1);

                        gsl_complex multiply = gsl_complex_mul_real(exp1, A);
                        u = gsl_complex_add(u, multiply);
                    }
                }

                double U = gsl_complex_abs(u);

                //zapisanie wartości do pliku
                plik << x << "\t" << y << "\t" << U << "\n";

            }



            plik << "\n";
        }

    }


    plik.close();
    gsl_matrix_free(gamma);
    gsl_matrix_free(V);
    gsl_vector_free(S);
    gsl_vector_free(work);
}
Пример #9
0
/**
 * Set up a full multi-dimensional grid-scan.
 * Currently this only emulates a 'factored' grid-scan with 'sky x Freq x f1dot ...' , but
 * keeps all details within the DopplerScan module for future extension to real multidimensional
 * grids.
 *
 * NOTE: Use 'XLALNextDopplerPos()' to step through this template grid.
 *
 */
DopplerFullScanState *
XLALInitDopplerFullScan ( const DopplerFullScanInit *init       /**< [in] initialization parameters */
                          )
{
  XLAL_CHECK_NULL ( init != NULL, XLAL_EINVAL );

  DopplerFullScanState *thisScan;
  XLAL_CHECK_NULL ( (thisScan = LALCalloc (1, sizeof(*thisScan) )) != NULL, XLAL_ENOMEM );

  thisScan->gridType = init->gridType;

  /* store the user-input spinRange (includes refTime) in DopplerFullScanState */
  thisScan->spinRange.refTime = init->searchRegion.refTime;
  memcpy ( thisScan->spinRange.fkdot, init->searchRegion.fkdot, sizeof(PulsarSpins) );
  memcpy ( thisScan->spinRange.fkdotBand, init->searchRegion.fkdotBand, sizeof(PulsarSpins) );

  // check that some old metric-codes aren't used with refTime!=startTime, which they don't handle correctly
  switch ( thisScan->gridType )
    {
    case GRID_METRIC:
    case GRID_METRIC_SKYFILE:
    case GRID_SPINDOWN_SQUARE: /* square parameter space */
    case GRID_SPINDOWN_AGEBRK: /* age-braking index parameter space */

      XLAL_CHECK_NULL ( XLALGPSDiff ( &init->startTime, &init->searchRegion.refTime ) == 0, XLAL_EINVAL,
                        "NOTE: gridType={metric,4,spin-square,spin-age-brk} only work for refTime (%f) == startTime (%f)!\n",
                        XLALGPSGetREAL8(&(init->searchRegion.refTime)), XLALGPSGetREAL8(&(init->startTime)) );;

      break;
    default:
      break;
    }

  /* which "class" of template grid to generate?: factored, or full-multidim ? */
  switch ( thisScan->gridType )
    {
      /* emulate old 'factored' grids 'sky x f0dot x f1dot x f2dot x f3dot': */
    case GRID_FLAT:
    case GRID_ISOTROPIC:
    case GRID_METRIC:
    case GRID_FILE_SKYGRID:
    case GRID_METRIC_SKYFILE:
      /* backwards-compatibility mode */
      XLAL_CHECK_NULL ( XLALInitFactoredGrid ( thisScan, init ) == XLAL_SUCCESS, XLAL_EFUNC );
      break;

      /* ----- multi-dimensional covering of full parameter space ----- */
    case GRID_FILE_FULLGRID:
      XLAL_CHECK_NULL ( XLALLoadFullGridFile ( thisScan, init ) == XLAL_SUCCESS, XLAL_EFUNC );
      break;

    case GRID_SPINDOWN_SQUARE: /* square parameter space */
    case GRID_SPINDOWN_AGEBRK: /* age-braking index parameter space */
      {
        const size_t n = 2 + PULSAR_MAX_SPINS;

        /* Check that the reference time is the same as the start time */
        XLAL_CHECK_NULL ( XLALGPSCmp ( &thisScan->spinRange.refTime, &init->startTime) == 0, XLAL_EINVAL,
                          "\nGRID_SPINDOWN_{SQUARE,AGEBRK}: This option currently restricts the reference time to be the same as the start time.\n");

        /* Create a vector to hold lattice tiling parameter-space points */
        XLAL_CHECK_NULL ( (thisScan->spindownTilingPoint = gsl_vector_alloc(n)) != NULL, XLAL_ENOMEM,
                          "\nGRID_SPINDOWN_{SQUARE,AGEBRK}: gsl_vector_alloc failed\n");

        /* Create a lattice tiling */
        XLAL_CHECK_NULL ( (thisScan->spindownTiling = XLALCreateLatticeTiling(n)) != NULL, XLAL_EFUNC );

        /* Parse the sky region string and check that it consists of only one point, and set bounds on it */
        SkyRegion XLAL_INIT_DECL(sky);
        XLAL_CHECK_NULL ( XLALParseSkyRegionString ( &sky, init->searchRegion.skyRegionString ) == XLAL_SUCCESS, XLAL_EFUNC );
        XLAL_CHECK_NULL ( sky.numVertices == 1, XLAL_EINVAL, "\nGRID_SPINDOWN_{SQUARE,AGEBRK}: This option can only handle a single sky position.\n");
        XLAL_CHECK_NULL ( sky.vertices[0].system == COORDINATESYSTEM_EQUATORIAL, XLAL_EINVAL, "\nGRID_SPINDOWN_{SQUARE,AGEBRK}: This option only understands COORDINATESYSTEM_EQUATORIAL\n");

        XLAL_CHECK_NULL ( XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 0, sky.vertices[0].longitude, sky.vertices[0].longitude) == XLAL_SUCCESS, XLAL_EFUNC );

        XLAL_CHECK_NULL ( XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 1, sky.vertices[0].latitude, sky.vertices[0].latitude) == XLAL_SUCCESS, XLAL_EFUNC );
        if (sky.vertices) {
          XLALFree (sky.vertices);
        }

        /* Set up parameter space */
        if (thisScan->gridType == GRID_SPINDOWN_SQUARE) { /* square parameter space */

          /* Set square bounds on the frequency and spindowns */
          for (size_t i = 0; i < PULSAR_MAX_SPINS; ++i) {
            XLAL_CHECK_NULL ( XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 2 + i, init->searchRegion.fkdot[i], init->searchRegion.fkdot[i] + init->searchRegion.fkdotBand[i]) == XLAL_SUCCESS, XLAL_EFUNC );
          }

        } else if (thisScan->gridType == GRID_SPINDOWN_AGEBRK) { /* age-braking index parameter space */

          /* Get age and braking index from extra arguments */
          const REAL8 spindownAge = init->extraArgs[0];
          const REAL8 minBraking = init->extraArgs[1];
          const REAL8 maxBraking = init->extraArgs[2];

          /* Set age-braking index parameter space */
          XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 2, init->searchRegion.fkdot[0], init->searchRegion.fkdot[0] + init->searchRegion.fkdotBand[0]), XLAL_EFUNC );
          XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingF1DotAgeBrakingBound(thisScan->spindownTiling, 2, 3, spindownAge, minBraking, maxBraking), XLAL_EFUNC );
          XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingF2DotBrakingBound(thisScan->spindownTiling, 2, 3, 4, minBraking, maxBraking), XLAL_EFUNC );

          /* This current only goes up to second spindown, so bound higher dimensions */
          for (size_t i = 3; i < PULSAR_MAX_SPINS; ++i) {
            XLAL_CHECK_NULL ( XLAL_SUCCESS == XLALSetLatticeTilingConstantBound(thisScan->spindownTiling, 2 + i, init->searchRegion.fkdot[i], init->searchRegion.fkdot[i] + init->searchRegion.fkdotBand[i]), XLAL_EFUNC );
          }

        }

        /* Create a lattice tiling with Anstar lattice and spindown metric */
        gsl_matrix* metric;
        XLAL_CHECK_NULL ( (metric = gsl_matrix_alloc(n, n)) != NULL, XLAL_ENOMEM );
        gsl_matrix_set_identity(metric);
        gsl_matrix_view spin_metric = gsl_matrix_submatrix(metric, 2, 2, PULSAR_MAX_SPINS, PULSAR_MAX_SPINS);
        XLAL_CHECK_NULL ( XLALSpindownMetric(&spin_metric.matrix, init->Tspan) == XLAL_SUCCESS, XLAL_EFUNC );
        XLAL_CHECK_NULL ( XLALSetTilingLatticeAndMetric(thisScan->spindownTiling, "Ans", metric, init->metricMismatch) == XLAL_SUCCESS, XLAL_EFUNC );

        /* Create iterator over flat lattice tiling */
        XLAL_CHECK_NULL ( (thisScan->spindownTilingItr = XLALCreateLatticeTilingIterator(thisScan->spindownTiling, n)) != NULL, XLAL_EFUNC );

        /* Cleanup */
        gsl_matrix_free(metric);

      }

      break;

    default:
      XLAL_ERROR_NULL ( XLAL_EINVAL, "\nInvalid grid type '%d'\n\n", init->gridType );
      break;
    } /* switch gridType */

  /* we're ready */
  thisScan->state = STATE_READY;

  /* return result */
  return thisScan;

} // XLALInitDopplerFullScan()
Пример #10
0
//Fitting. Allow fitting multiple q curves simultaneously to decrease the chance of converging to local minimum.
void ddm::fitting()
{
    int cnum_fit=num_fit;
    int ctimeWindow=timeWindow;
    //Find the truncation time if time window is set
    for (int itert=0; itert<num_fit; ++itert)
    {
        if (tau[itert]>ctimeWindow)
        {
            cnum_fit=itert;
            break;
        }
    }
    
    //Local variables
    int cqsize=qsize-qIncreList[num_qCurve-1];  //number of fitting result
    int cnum_qCurve=num_qCurve;
    int ctnum_fit=cnum_fit*num_qCurve;
    int cnumOfPara=numOfPara+2*num_qCurve;  //Total number of parameters
    
    fittedPara=gsl_matrix_alloc(cqsize, cnumOfPara);
    //To store the fitting result and error.
    fitErr=gsl_matrix_alloc(cqsize, cnumOfPara);
    status = new int[cqsize];		//Record the status of fitting.
    
    //Using Levenberg-Marquardt algorithm as implemented in the scaled lmder routine in minpack. Jacobian is given.
    const gsl_multifit_fdfsolver_type *solverType = gsl_multifit_fdfsolver_lmsder;
    
    int progress=0;		//Indicator of progress.
    
    //Objects to do numerical inverse Laplace transformation
#ifdef ISFRTD
    NILT NILT1(OMP_NUM_THREADS), NILT2(OMP_NUM_THREADS), NILT3(OMP_NUM_THREADS), NILT4(OMP_NUM_THREADS);
#endif
    
#ifdef ISFRTDP
    NILT NILT1(OMP_NUM_THREADS), NILT2(OMP_NUM_THREADS), NILT3(OMP_NUM_THREADS), NILT4(OMP_NUM_THREADS), NILT5(OMP_NUM_THREADS);
#endif
    
#ifdef ISFRTDPTT
    NILT NILT1(OMP_NUM_THREADS), NILT2(OMP_NUM_THREADS), NILT3(OMP_NUM_THREADS), NILT4(OMP_NUM_THREADS), NILT5(OMP_NUM_THREADS), NILT6(OMP_NUM_THREADS);
#endif
    
#ifdef ISFRTDPfix
    NILT NILT1(OMP_NUM_THREADS), NILT2(OMP_NUM_THREADS);
    
    const long double vbar=vbarGuess;
    const long double sigma=sigmaGuess;
    
    const long double vbsigma2=vbar/sigma/sigma;
    const long double vb2sigma2=vbsigma2*vbar;
    const long double logvbsigma2=log(vbsigma2);
    const long double logfactor=vb2sigma2*logvbsigma2-gsl_sf_lngamma(vb2sigma2);
    const long double cpsiz1=logvbsigma2-gsl_sf_psi(vb2sigma2);
    const long double vb2sigma3=vb2sigma2/sigma;
#endif
    
#ifdef ISFRTDPTTfix
    NILT NILT1(OMP_NUM_THREADS), NILT2(OMP_NUM_THREADS), NILT3(OMP_NUM_THREADS);
    
    const long double vbar=vbarGuess;
    const long double sigma=sigmaGuess;
    
    const long double vbsigma2=vbar/sigma/sigma;
    const long double vb2sigma2=vbsigma2*vbar;
    const long double logvbsigma2=log(vbsigma2);
    const long double logfactor=vb2sigma2*logvbsigma2-gsl_sf_lngamma(vb2sigma2);
    const long double cpsiz1=logvbsigma2-gsl_sf_psi(vb2sigma2);
    const long double vb2sigma3=vb2sigma2/sigma;
#endif
    
#pragma omp parallel for
    for (int iterq=0; iterq<cqsize; ++iterq)
    {
        //Data array which is going to present to the fitting algorithm
        double* datafit=new double[ctnum_fit];
        double* qList=new double[cnum_qCurve];
        double* time=new double[ctnum_fit];
        //Truncate the data, and put multiple curves into one array
        for (int iterqc=0; iterqc<cnum_qCurve; ++iterqc)
        {
            for (int iterf = 0; iterf < cnum_fit; ++iterf)
            {
                datafit[iterf+iterqc*cnum_fit]=(gsl_matrix_get(datag, iterq+qIncreList[iterqc], iterf));		//Fitting in log scale.
                time[iterf+iterqc*cnum_fit]=tau[iterf];
            }
            qList[iterqc]=qabs[iterq+qIncreList[iterqc]];
        }
        
        gsl_multifit_function_fdf fitfun;		//Pointer of function to fit.
        dataStruct sdata;		//GSL data structure
        
        //Data is passed to ISFfun by sdata
        sdata.data=datafit;
        sdata.tau=time;
        sdata.q=qList;
        sdata.num_fit=cnum_fit;
        sdata.num_qCurve=cnum_qCurve;
        
#ifdef ISFRTD
        sdata.ISFILT=&NILT1;
        sdata.dvISFILT=&NILT2;
        sdata.dDISFILT=&NILT3;
        sdata.dlambdaISFILT=&NILT4;
#endif
        
#ifdef ISFRTDP
        sdata.ISFILT=&NILT1;
        sdata.dvbarISFILT=&NILT2;
        sdata.dsigmaISFILT=&NILT3;
        sdata.dDISFILT=&NILT4;
        sdata.dlambdaISFILT=&NILT5;
#endif
        
#ifdef ISFRTDPTT
        sdata.ISFILT=&NILT1;
        sdata.dvbarISFILT=&NILT2;
        sdata.dsigmaISFILT=&NILT3;
        sdata.dDISFILT=&NILT4;
        sdata.dlambdaISFILT=&NILT5;
        sdata.dTTISFILT=&NILT6;
#endif
        
#ifdef ISFRTDPfix
        sdata.alpha=alphaGuess;
        sdata.D=DGuess;
        sdata.vbar=vbar;
        sdata.sigma=sigma;
        
        sdata.vbsigma2=vbsigma2;
        sdata.logfactor=logfactor;
        sdata.vb2sigma2=vb2sigma2;
        sdata.cpsiz1=cpsiz1;
        sdata.vb2sigma3=vb2sigma3;
        sdata.ISFILT=&NILT1;
        sdata.dlambdaISFILT=&NILT2;
#endif
        
#ifdef ISFRTDPTTfix
        sdata.alpha=alphaGuess;
        sdata.D=DGuess;
        sdata.vbar=vbar;
        sdata.sigma=sigma;
        
        sdata.vbsigma2=vbsigma2;
        sdata.logfactor=logfactor;
        sdata.vb2sigma2=vb2sigma2;
        sdata.cpsiz1=cpsiz1;
        sdata.vb2sigma3=vb2sigma3;
        sdata.ISFILT=&NILT1;
        sdata.dlambdaISFILT=&NILT2;
        sdata.dTTISFILT=&NILT3;
#endif
        
        //API
        fitfun.f=&ISFfun;
#ifdef NoJacobian
        fitfun.df=0;
        fitfun.fdf=0;
#else
        fitfun.df=&dISFfun;
        fitfun.fdf=&fdISFfun;
#endif
        fitfun.n=ctnum_fit;
        fitfun.p=cnumOfPara;
        fitfun.params=&sdata;
        
        //Initialization of the parameters
        double* localinipara=new double[cnumOfPara];
        for (int iterp=0; iterp<numOfPara; ++iterp)
        {
            localinipara[iterp]=inipara[iterp];
        }
        //Estimation of A(q) and B(q)
        for (int iterqc=0; iterqc<num_qCurve; ++iterqc)
        {
            localinipara[numOfPara+1+2*iterqc] = gsl_matrix_get(datag, iterq+qIncreList[iterqc], 0);
            localinipara[numOfPara+2*iterqc] = gsl_matrix_get(datag, iterq+qIncreList[iterqc], num_fit-1)-localinipara[numOfPara+1+2*iterqc];
        }
        //Initiallization of the solver
        gsl_vector_view para=gsl_vector_view_array(localinipara, cnumOfPara);
        gsl_multifit_fdfsolver* solver = gsl_multifit_fdfsolver_alloc(solverType, ctnum_fit, cnumOfPara);
        gsl_multifit_fdfsolver_set(solver, &fitfun, &para.vector);
        int iter=0;
        //gsl_vector* g=gsl_vector_alloc(numOfPara);
        
        //For debugging and monitering the iterations
//        cout << qList[0] << ' ' << qList[1] << '\n';
//        for (int iterpara=0; iterpara<cnumOfPara; ++iterpara)
//        {
//            cout << gsl_vector_get(solver->x, iterpara) << '\n';
//        }
//        cout << '\n';
        
        int cstatus=GSL_CONTINUE;   //Current status
        do
        {
            gsl_multifit_fdfsolver_iterate(solver);		//Iterate one step.
            cstatus = norm0_rel_test(solver->dx, solver->x, 1e-7, 1e-7);  //Test the exiting criteria
            
            //For debugging and monitering the iterations
//            for (int iterpara=0; iterpara<cnumOfPara; ++iterpara)
//            {
//                cout << gsl_vector_get(solver->x, iterpara) << '\n';
//            }
//            cout << '\n';
            
            //If to use other exiting criteria
            //gsl_multifit_gradient(solver->J,solver->f, g);
            //status[iterq-1]=gsl_multifit_test_gradient(g, 1e-5);
            //			status[iterq - 1] = covar_rel_test(solver->J, solver->x, 1e-4);
            
            ++iter;
            //Number of iterations exceed certain limitation
            if (iter>maxIter)
            {
                cstatus=GSL_EMAXITER;
            }
        } while (cstatus == GSL_CONTINUE);
        status[iterq]=cstatus;
        //gsl_vector_free(g);
        
        //Estimating the error.
        gsl_matrix* covar=gsl_matrix_alloc(cnumOfPara, cnumOfPara);
        gsl_multifit_covar(solver->J, 0.0, covar);
        for (int iterpara=0; iterpara<cnumOfPara; ++iterpara)	//Record result.
        {
            gsl_matrix_set(fittedPara, iterq, iterpara, gsl_vector_get(solver->x, iterpara) );
            gsl_matrix_set(fitErr, iterq, iterpara, sqrt(gsl_matrix_get(covar, iterpara, iterpara)) );    //Not presice in log scale
        }
        gsl_matrix_free(covar);
        gsl_multifit_fdfsolver_free(solver);
        
        //Output to standard I/O
        progress+=1;
        cout << "Fitted q=" << qabs[iterq] << " at iter=" << iter << ", " << 100.0*progress / qsize << "% completed from thread No." << omp_get_thread_num() << ", "<< gsl_strerror(status[iterq]) << "." << '\n';
        for (int iterpara=0; iterpara<cnumOfPara; ++iterpara)
        {
            cout << gsl_matrix_get(fittedPara, iterq, iterpara) << '\n';
        }
        cout << '\n';
        delete [] datafit;
        delete [] qList;
        delete [] localinipara;
        delete [] time;
    }
}
Пример #11
0
QMap<double, double> SGMResolutionOptimization::curve(QList<QVariant> stateParameters, AMRegionsList* contextParameters){
	double _maxenergy = maximumEnergy(contextParameters);
	double _minenergy = minimumEnergy(contextParameters);
	double _slit = stateParameters.at(0).toDouble();
	double _y1, _y2, _y3, _x1, _x2, _x3;
	double _maxRes = 0;
	SGMBeamlineInfo::sgmGrating _grating = (SGMBeamlineInfo::sgmGrating)stateParameters.at(1).toInt();
	SGMBeamlineInfo::sgmHarmonic _harmonic = (SGMBeamlineInfo::sgmHarmonic)stateParameters.at(2).toInt();
	if(!SGMBeamlineInfo::sgmInfo()->energyRangeValidForSettings(_grating, _harmonic, _minenergy, _maxenergy))
	{
	}
	else if((_harmonic == 3) && (_grating == 2)){
		_y1 = (0.95)*(0.5229*log(_slit)+1.4221);
		_y2 = (0.95)*(0.4391*log(_slit)+1.2617);
		_y3 = (0.95)*(0.421*log(_slit)+0.9037);
		_x1 = 2000;
		_x2 = 1200;
		_x3 = 800;
		_maxRes = 12500;
	}
	else{
		if( (_grating == 0) && SGMBeamlineInfo::sgmInfo()->energyRangeValidForSettings(_grating, _harmonic, _minenergy, _maxenergy) ){
			_y1 = 0.4568*log(_slit)+1.0199;
			_y2 = 0.4739*log(_slit)+0.605;
			_y3 = 0.4257*log(_slit)+0.4438;
			_x1 = 600;
			_x2 = 400;
			_x3 = 250;
			_maxRes = 17500;
		}
		else if( (_grating == 1) && SGMBeamlineInfo::sgmInfo()->energyRangeValidForSettings(_grating, _harmonic, _minenergy, _maxenergy) ){
			_y1 = 0.425*log(_slit)+1.4936;
			_y2 = 0.4484*log(_slit)+1.0287;
			_y3 = 0.4029*log(_slit)+0.7914;
			_x1 = 1200;
			_x2 = 800;
			_x3 = 500;
			_maxRes = 15000;
		}
		else if( (_grating == 2) && SGMBeamlineInfo::sgmInfo()->energyRangeValidForSettings(_grating, _harmonic, _minenergy, _maxenergy) ){
			_y1 = 0.5229*log(_slit)+1.4221;
			_y2 = 0.4391*log(_slit)+1.2617;
			_y3 = 0.421*log(_slit)+0.9037;
			_x1 = 2000;
			_x2 = 1200;
			_x3 = 800;
			_maxRes = 13750;
		}
	}
	int i, n;
	double xi, yi, ei, chisq;
	gsl_matrix *X, *cov;
	gsl_vector *y, *w, *c;

	n = 3;

	X = gsl_matrix_alloc (n, 3);
	y = gsl_vector_alloc (n);
	w = gsl_vector_alloc (n);

	c = gsl_vector_alloc (3);
	cov = gsl_matrix_alloc (3, 3);

	double ix[3];
	double iy[3];
	double ie[3];
	ix[0] = _x1;
	ix[1] = _x2;
	ix[2] = _x3;
	iy[0] = _y1;
	iy[1] = _y2;
	iy[2] = _y3;
	ie[0] = 0.1*iy[0];
	ie[1] = 0.1*iy[1];
	ie[2] = 0.1*iy[2];
	for (i = 0; i < n; i++)
	{
		xi = ix[i];
		yi = iy[i];
		ei = ie[i];

		gsl_matrix_set (X, i, 0, 1.0);
		gsl_matrix_set (X, i, 1, xi);
		gsl_matrix_set (X, i, 2, xi*xi);

		gsl_vector_set (y, i, yi);
		gsl_vector_set (w, i, 1.0/(ei*ei));
	}

	gsl_multifit_linear_workspace * work
			= gsl_multifit_linear_alloc (n, 3);
	gsl_multifit_wlinear (X, w, y, c, cov,
				  &chisq, work);
	gsl_multifit_linear_free (work);

#define C(i) (gsl_vector_get(c,(i)))
#define COV(i,j) (gsl_matrix_get(cov,(i),(j)))

	QMap<double, double> rCurve;
	double tmpStart, tmpEnd, tmpDelta;//, tmpVal;
	for( int x = 0; x < contextParameters->count(); x++){
		tmpStart = contextParameters->start(x);
		tmpDelta = contextParameters->delta(x);
		tmpEnd = contextParameters->end(x);

		if( tmpStart >= 250 && tmpStart <= 2000 && tmpEnd >= 250 && tmpEnd <= 2000 ){
			for( double y = tmpStart; ((tmpDelta > 0) ? (y <= tmpEnd) : (y >= tmpEnd)); y += tmpDelta ){
				//rCurve[y] = !SGMBeamline::sgm()->energyValidForSettings(_grating, _harmonic, y) ? 0.0 :y/(pow(10, C(2)*y*y + C(1)*y + C(0))*1e-3);
				if(!SGMBeamlineInfo::sgmInfo()->energyValidForSettings(_grating, _harmonic, y))
					rCurve[y] = 0.0;
				else{
					rCurve[y] = y/(pow(10, C(2)*y*y + C(1)*y + C(0))*1e-3);
				}
			}
		}
		else
			rCurve[250] = 0;
	}


	gsl_matrix_free (X);
	gsl_vector_free (y);
	gsl_vector_free (w);
	gsl_vector_free (c);
	gsl_matrix_free (cov);
	return rCurve;
}
Пример #12
0
void freeNbProposals(NbProposals *NbProp)
{
    gsl_matrix_free(NbProp->NbProp_beta);

    free(NbProp);
}
Пример #13
0
void freeIsAcceptOK(isAcceptOK *acceptOK)
{
    gsl_matrix_free(acceptOK->IsAccOK_beta);

    free(acceptOK);
}
Пример #14
0
void freeAcceptance(acceptance *accept)
{
    gsl_matrix_free(accept->PourcAcc_beta);

    free(accept);
}
Пример #15
0
            /* Produce a vector of chisquared values as a function of frequency */
void    fastChi(const double *sampletimes, const float *vals, const float *stderrs, 
                long ndata, long nharmonics, double deltat, 
                long nrealpoints, long nchivalues, double tstart,
                float *dovstorage, float *oovstorage,
                float *chireductionlist)
{
    int d;
    int i;
    int h;
    float invdeltat = 1/deltat;

    gsl_matrix *alpha = gsl_matrix_alloc(2 * nharmonics + 1,2 * nharmonics + 1);
    gsl_vector *beta =  gsl_vector_alloc(2 * nharmonics + 1);
    gsl_vector *x    =  gsl_vector_alloc(2 * nharmonics + 1);

    float *cosdata = malloc((nharmonics + 1) * sizeof(float));
    float *sindata = malloc((nharmonics + 1) * sizeof(float));
    float *cosvar = malloc((2*nharmonics + 1) * sizeof(float));
    float *sinvar = malloc((2*nharmonics + 1) * sizeof(float));

        /* if the pointers point somewhere, assume that they point to the right place */
    assert(sampletimes && vals && stderrs && dovstorage && oovstorage && chireductionlist);
    assert(nchivalues * 2 * nharmonics <= nrealpoints); /* FIXME: change 2 to 1 when */
                                                        /* using aliasing */
    assert(cosdata && sindata && cosvar && sinvar);
    
    memset(dovstorage, 0, nrealpoints * sizeof(float));
    memset(oovstorage, 0, nrealpoints * sizeof(float));
    
    for (d = 0 ; d < ndata ; d++)
    {
        long tindex = (sampletimes[d] - tstart) * invdeltat;
        float inv_variance = 1/(stderrs[d] * stderrs[d]); 
        assert(tindex >= 0 && tindex < nrealpoints);
                /* adding rather than setting averages measurments that */
                /* fall in same timebin.  It does, however, reduce the d.o.f. */
                /* and subsequently improperly reduces the chisquared.  */
                /* This is a minor point. */
            /* dov: _d_ata _o_ver _v_ariance  oov: _o_ne  _o_ver _v_ariance */
        dovstorage[tindex] += vals[d] * inv_variance;
        oovstorage[tindex] += inv_variance;
    }
    gsl_fft_real_float_radix2_transform(dovstorage, 1, nrealpoints);
    gsl_fft_real_float_radix2_transform(oovstorage, 1, nrealpoints);

    cosdata[0] = dovstorage[0];     /* The constant (0f) terms are the same for all f */
    cosvar[0] = oovstorage[0];

    for (i = 1 ; i < nchivalues ; i++)
    {
        for (h = 1 ; h <= nharmonics ; h++)
        {
            cosdata[h] = dovstorage[i*h];
            sindata[h] = dovstorage[nrealpoints - (i * h)] * FFTSIGNCONVENTION;
        }
        for (h = 1 ; h <= 2*nharmonics ; h++)
        {                               /* put alias wrapping in here */
            cosvar[h] = oovstorage[i*h];
            sinvar[h] = oovstorage[nrealpoints - (i * h)] * FFTSIGNCONVENTION;
        }
        chireductionlist[i] 
                = calcChiReduction(nharmonics,
                                cosdata, sindata, cosvar, sinvar,
                                alpha, beta, x);
    }

        
    gsl_matrix_free(alpha);
    gsl_vector_free(beta);
    gsl_vector_free(x);

    free(cosdata);
    free(sindata);
    free(cosvar);
    free(sinvar);

}
Пример #16
0
void
test_eigen_symm(void)
{
  size_t N_max = 20;
  size_t n, i;
  gsl_rng *r = gsl_rng_alloc(gsl_rng_default);

  for (n = 1; n <= N_max; ++n)
    {
      gsl_matrix * A = gsl_matrix_alloc(n, n);

      for (i = 0; i < 5; ++i)
        {
          create_random_symm_matrix(A, r, -10, 10);
          test_eigen_symm_matrix(A, i, "symm random");
        }

      gsl_matrix_free(A);
    }

  gsl_rng_free(r);

  {
    double dat1[] =  { 0,  0, -1,  0, 
                       0,  1,  0,  1,
                       -1,  0,  0,  0,
                       0,  1,  0,  0 };
    double dat2[] =  { 1,  0,  0,  0, 
                       0,  2,  0,  0,
                       0,  0,  3,  0,
                       0,  0,  0,  4 };
    gsl_matrix_view m;

    m = gsl_matrix_view_array (dat1, 4, 4);
    test_eigen_symm_matrix(&m.matrix, 0, "symm(4)");

    m = gsl_matrix_view_array (dat2, 4, 4);
    test_eigen_symm_matrix(&m.matrix, 0, "symm(4) diag");
  }

  { 
    double dat[27*27] = {
	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,
	0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,0,
	0,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
	0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
    };
        
    gsl_matrix_view m;
    m = gsl_matrix_view_array (dat, 27, 27);
    test_eigen_symm_matrix(&m.matrix, 0, "symm(27)");
  };

} /* test_eigen_symm() */
Пример #17
0
static int
lmder_alloc (void *vstate, size_t n, size_t p)
{
  lmder_state_t *state = (lmder_state_t *) vstate;
  gsl_matrix *r;
  gsl_vector *tau, *diag, *qtf, *newton, *gradient, *x_trial, *f_trial,
   *df, *sdiag, *rptdx, *w, *work1;
  gsl_permutation *perm;

  r = gsl_matrix_calloc (n, p);

  if (r == 0)
    {
      GSL_ERROR ("failed to allocate space for r", GSL_ENOMEM);
    }

  state->r = r;

  tau = gsl_vector_calloc (GSL_MIN(n, p));

  if (tau == 0)
    {
      gsl_matrix_free (r);

      GSL_ERROR ("failed to allocate space for tau", GSL_ENOMEM);
    }

  state->tau = tau;

  diag = gsl_vector_calloc (p);

  if (diag == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);

      GSL_ERROR ("failed to allocate space for diag", GSL_ENOMEM);
    }

  state->diag = diag;

  qtf = gsl_vector_calloc (n);

  if (qtf == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);

      GSL_ERROR ("failed to allocate space for qtf", GSL_ENOMEM);
    }

  state->qtf = qtf;

  newton = gsl_vector_calloc (p);

  if (newton == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);

      GSL_ERROR ("failed to allocate space for newton", GSL_ENOMEM);
    }

  state->newton = newton;

  gradient = gsl_vector_calloc (p);

  if (gradient == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);

      GSL_ERROR ("failed to allocate space for gradient", GSL_ENOMEM);
    }

  state->gradient = gradient;

  x_trial = gsl_vector_calloc (p);

  if (x_trial == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);

      GSL_ERROR ("failed to allocate space for x_trial", GSL_ENOMEM);
    }

  state->x_trial = x_trial;

  f_trial = gsl_vector_calloc (n);

  if (f_trial == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);

      GSL_ERROR ("failed to allocate space for f_trial", GSL_ENOMEM);
    }

  state->f_trial = f_trial;

  df = gsl_vector_calloc (n);

  if (df == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);

      GSL_ERROR ("failed to allocate space for df", GSL_ENOMEM);
    }

  state->df = df;

  sdiag = gsl_vector_calloc (p);

  if (sdiag == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);

      GSL_ERROR ("failed to allocate space for sdiag", GSL_ENOMEM);
    }

  state->sdiag = sdiag;


  rptdx = gsl_vector_calloc (n);

  if (rptdx == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);
      gsl_vector_free (sdiag);

      GSL_ERROR ("failed to allocate space for rptdx", GSL_ENOMEM);
    }

  state->rptdx = rptdx;

  w = gsl_vector_calloc (n);

  if (w == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);
      gsl_vector_free (sdiag);
      gsl_vector_free (rptdx);

      GSL_ERROR ("failed to allocate space for w", GSL_ENOMEM);
    }

  state->w = w;

  work1 = gsl_vector_calloc (p);

  if (work1 == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);
      gsl_vector_free (sdiag);
      gsl_vector_free (rptdx);
      gsl_vector_free (w);

      GSL_ERROR ("failed to allocate space for work1", GSL_ENOMEM);
    }

  state->work1 = work1;

  perm = gsl_permutation_calloc (p);

  if (perm == 0)
    {
      gsl_matrix_free (r);
      gsl_vector_free (tau);
      gsl_vector_free (diag);
      gsl_vector_free (qtf);
      gsl_vector_free (newton);
      gsl_vector_free (gradient);
      gsl_vector_free (x_trial);
      gsl_vector_free (f_trial);
      gsl_vector_free (df);
      gsl_vector_free (sdiag);
      gsl_vector_free (rptdx);
      gsl_vector_free (w);
      gsl_vector_free (work1);

      GSL_ERROR ("failed to allocate space for perm", GSL_ENOMEM);
    }

  state->perm = perm;

  return GSL_SUCCESS;
}
Пример #18
0
void
test_eigen_gensymm(void)
{
  size_t N_max = 20;
  size_t n, i;
  gsl_rng *r = gsl_rng_alloc(gsl_rng_default);

  for (n = 1; n <= N_max; ++n)
    {
      gsl_matrix * A = gsl_matrix_alloc(n, n);
      gsl_matrix * B = gsl_matrix_alloc(n, n);
      gsl_matrix * ma = gsl_matrix_alloc(n, n);
      gsl_matrix * mb = gsl_matrix_alloc(n, n);
      gsl_vector * eval = gsl_vector_alloc(n);
      gsl_vector * evalv = gsl_vector_alloc(n);
      gsl_vector * x = gsl_vector_alloc(n);
      gsl_vector * y = gsl_vector_alloc(n);
      gsl_matrix * evec = gsl_matrix_alloc(n, n);
      gsl_eigen_gensymm_workspace * w = gsl_eigen_gensymm_alloc(n);
      gsl_eigen_gensymmv_workspace * wv = gsl_eigen_gensymmv_alloc(n);

      for (i = 0; i < 5; ++i)
        {
          create_random_symm_matrix(A, r, -10, 10);
          create_random_posdef_matrix(B, r);

          gsl_matrix_memcpy(ma, A);
          gsl_matrix_memcpy(mb, B);

          gsl_eigen_gensymmv(ma, mb, evalv, evec, wv);
          test_eigen_gensymm_results(A, B, evalv, evec, i, "random", "unsorted");

          gsl_matrix_memcpy(ma, A);
          gsl_matrix_memcpy(mb, B);

          gsl_eigen_gensymm(ma, mb, eval, w);

          /* eval and evalv have to be sorted? not sure why */
          gsl_vector_memcpy(x, eval);
          gsl_vector_memcpy(y, evalv);
          gsl_sort_vector(x);
          gsl_sort_vector(y);
          test_eigenvalues_real(y, x, "gensymm, random", "unsorted");

          gsl_eigen_gensymmv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_ASC);
          test_eigen_gensymm_results(A, B, evalv, evec, i, "random", "val/asc");

          gsl_eigen_gensymmv_sort(evalv, evec, GSL_EIGEN_SORT_VAL_DESC);
          test_eigen_gensymm_results(A, B, evalv, evec, i, "random", "val/desc");

          gsl_eigen_gensymmv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_ASC);
          test_eigen_gensymm_results(A, B, evalv, evec, i, "random", "abs/asc");
          gsl_eigen_gensymmv_sort(evalv, evec, GSL_EIGEN_SORT_ABS_DESC);
          test_eigen_gensymm_results(A, B, evalv, evec, i, "random", "abs/desc");
        }

      gsl_matrix_free(A);
      gsl_matrix_free(B);
      gsl_matrix_free(ma);
      gsl_matrix_free(mb);
      gsl_vector_free(eval);
      gsl_vector_free(evalv);
      gsl_vector_free(x);
      gsl_vector_free(y);
      gsl_matrix_free(evec);
      gsl_eigen_gensymm_free(w);
      gsl_eigen_gensymmv_free(wv);
    }

  gsl_rng_free(r);
} /* test_eigen_gensymm() */
Пример #19
0
void experiment::run_experiment()
{
	parameter pdebug = get_param("debugprint");
	parameter pdebug_f = get_param("debugprint_file");
	pdebug.strvalue=pdebug_f.strvalue;
	std::string sverbfile=get_param_s("verbose_file");
	bool bverbose=(get_param_i("verbose_mode")==1);
	std::ofstream fverbose;
	if (sverbfile.compare("cout")==0)
		gout=&std::cout;
	else
	{
		fverbose.open(sverbfile.c_str());
	       	gout=&fverbose;
	};

	//used algorithms
	std::string sexp_type=get_param_s("exp_type");
	std::string salgo_match=get_param_s("algo");
	std::istrstream istr(salgo_match.c_str());
	std::vector<std::string>v_salgo_match;
	std::string stemp;
	while (istr>>stemp)
		v_salgo_match.push_back(stemp);
	//used initialization algorithms
	std::string salgo_init=get_param_s("algo_init_sol");
	std::istrstream istrinit(salgo_init.c_str());
	std::vector<std::string>v_salgo_init;
	while (istrinit>>stemp)
		v_salgo_init.push_back(stemp);
	if (v_salgo_init.size()!=v_salgo_match.size())
		{
			printf("Error: algo and algo_init_sol do not have the same size\n");
			exit(0);
		};

	double dalpha_ldh=get_param_d("alpha_ldh");
	if ((dalpha_ldh<0) ||(dalpha_ldh>1))
	{
		printf("Error:alpha_ldh should be between 0 and 1 \n");
		exit(0);
	};

	graph g(get_config());
	graph h(get_config());
	char cformat1='D',cformat2='D';
	if (bverbose) *gout<<"Data loading"<<std::endl;
	g.load_graph(get_param_s("graph_1"),'A',cformat1);
	h.load_graph(get_param_s("graph_2"),'A',cformat2);
	if (get_param_i("graph_dot_print")==1){ g.printdot("g.dot");h.printdot("h.dot");};
	// Matrix of local similarities between graph vertices
	std::string strfile=get_param_s("C_matrix");
	int N1 =g.get_adjmatrix()->size1;
	int N2 =h.get_adjmatrix()->size1;
 	gsl_matrix* gm_ldh=gsl_matrix_alloc(N1,N2);
	FILE *f=fopen(strfile.c_str(),"r");
	if (f!=NULL){
		gsl_set_error_handler_off();
		int ierror=gsl_matrix_fscanf(f,gm_ldh);
		fclose(f);
		gsl_set_error_handler(NULL);
		if (ierror!=0){ printf("Error: C_matrix is not correctly defined \n"); exit(0);};
		}
	else
	{
		if (bverbose) *gout<<"C matrix is set to constant"<<std::endl;
                dalpha_ldh=0;
		gsl_matrix_set_all(gm_ldh,1.0/(N1*N2));
	};
	//inverse the sign if C is a distance matrix
	if (get_param_i("C_matrix_dist")==1)
		gsl_matrix_scale(gm_ldh,-1);

	if (bverbose) *gout<<"Graph synhronization"<<std::endl;
	synchronize(g,h,&gm_ldh);

	//Cycle over all algoirthms
	for (int a=0;a<v_salgo_match.size();a++)
		{
			//initialization
			algorithm* algo_i=get_algorithm(v_salgo_init[a]);
			algo_i->read_config(get_config_string());
			algo_i->set_ldhmatrix(gm_ldh);
			match_result mres_i=algo_i->gmatch(g,h,NULL,NULL,dalpha_ldh);
			delete algo_i;
			//main algorithm
			algorithm* algo=get_algorithm(v_salgo_match[a]);
			algo->read_config(get_config_string());
			algo->set_ldhmatrix(gm_ldh);
			match_result mres_a=algo->gmatch(g,h,(mres_i.gm_P_exact!=NULL)?mres_i.gm_P_exact:mres_i.gm_P, NULL,dalpha_ldh);
			mres_a.vd_trace.clear();
			mres_a.salgo=v_salgo_match[a];
			v_mres.push_back(mres_a);
			delete algo;
		};
	gsl_matrix_free(gm_ldh);
	printout();
}
Пример #20
0
void ssm_var_free(ssm_var_t *var)
{
    gsl_matrix_free(var);
}
Пример #21
0
void simTransition_Neuro(gsl_rng *random, double *y, int dy, int dx, int time, int N, double *param, double *xh, double *x)
{
	int i,k,s, npx=pow(dx,2), ddx=dx/2;
	double muI;
	double *mu=NULL, *wSim=NULL;

	double **M = (double**)malloc (sizeof (double)*N);

	for(i=0;i<N;i++)
	{
		M[i] =  (double*)malloc (sizeof (double)*dx);
	}

	gsl_matrix *SIGMA=gsl_matrix_alloc(dx/2,dx/2);

	//Compute  A*X+mux

	for(i=0;i<N;i++)
	{
		for(k=0;k<dx/2;k++)
		{
			M[i][k]=param[k];
			for(s=0;s<dx;s++)
			{
				M[i][k]+=param[dx*(k+1)+s]*(xh[dx*i+s]-param[s]);
			}
		}

		for(k=dx/2;k<dx;k++)
		{
			x[dx*i+k]=param[k];
			for(s=0;s<dx;s++)
			{
				x[dx*i+k]+=param[dx*(k+1)+s]*(xh[dx*i+s]-param[s]);
			}
		}
	}
		
	//Choletsky decomposition of Sigma

	for(k=0;k<dx/2;k++)
	{
		for(s=0;s<dx/2;s++)
		{
			gsl_matrix_set(SIGMA,k,s,param[dx+npx+dx*k/2+s]);
		}
	}


	//Simulation

	mu=(double*)malloc(sizeof(double)*(dx/2));
	wSim=(double*)malloc(sizeof(double)*(dx/2));

	for(i=0;i<N;i++)
	{
		for(k=0;k<dx/2;k++)
		{
			mu[k]=M[i][k];
		}

		rmnorm(random,ddx, mu, SIGMA, wSim);

		for(k=0;k<dx/2;k++)
		{
			x[dx*i+k]=wSim[k];
		}
	}
	
	free(mu);
	mu=NULL;
	free(wSim);
	wSim=NULL;
	gsl_matrix_free(SIGMA);
	SIGMA=NULL;



	for (i = 0; i < N; i++)
	{
  		free(M[i]);
	}
	free (M);
	
}
Пример #22
0
void ssm_calc_free(ssm_calc_t *calc, ssm_nav_t *nav)
{
    gsl_rng_free(calc->randgsl);

    if (nav->implementation == SSM_ODE  || nav->implementation == SSM_EKF){

        gsl_odeiv2_step_free(calc->step);
        gsl_odeiv2_evolve_free(calc->evolve);
        gsl_odeiv2_control_free(calc->control);

        if(nav->implementation == SSM_EKF){
            gsl_vector_free(calc->_pred_error);
            gsl_matrix_free(calc->_St);
            gsl_matrix_free(calc->_Stm1);
            gsl_matrix_free(calc->_Rt);
            gsl_matrix_free(calc->_Ht);
            gsl_matrix_free(calc->_Kt);
            gsl_matrix_free(calc->_Tmp_N_SV_N_TS);
            gsl_matrix_free(calc->_Tmp_N_TS_N_SV);
            gsl_matrix_free(calc->_Q);
            gsl_matrix_free(calc->_FtCt);
            gsl_matrix_free(calc->_Ft);
            gsl_vector_free(calc->_eval);
            gsl_matrix_free(calc->_evec);
            gsl_eigen_symmv_free(calc->_w_eigen_vv);
        }

    } else if (nav->implementation == SSM_SDE){
        free(calc->y_pred);
    } else if (nav->implementation == SSM_PSR){
        ssm_psr_free(calc);
    }

    free(calc->to_be_sorted);
    free(calc->index_sorted);

    if(calc->covariates_length){
        int k;
        for(k=0; k< calc->covariates_length; k++) {
            if(calc->spline[k]){
                gsl_spline_free(calc->spline[k]);
            }
            if(calc->acc[k]){
                gsl_interp_accel_free(calc->acc[k]);
            }
        }

        free(calc->spline);
        free(calc->acc);
    }

    free(calc);
}
Пример #23
0
void infomax(gsl_matrix *x_white, gsl_matrix *weights, gsl_matrix *S, int  verbose){
  /*Computes ICA infomax in whitened data
    Decomposes x_white as x_white=AS
    *Input
    x_white: whitened data (Use PCAwhiten)
    *Output
    A : mixing matrix
    S : source matrix
  */
  // int verbose = 1; //true
  size_t NCOMP = x_white->size1;
  size_t NVOX = x_white->size2;

  //getting permutation vector
  const gsl_rng_type * T;
  gsl_rng * r;
  gsl_permutation * p = gsl_permutation_alloc (NVOX);
  // gsl_rng_env_setup();
  T = gsl_rng_default;
  r = gsl_rng_alloc (T);
  gsl_permutation_init (p);

  gsl_matrix *old_weights    = gsl_matrix_alloc(NCOMP,NCOMP);
  gsl_matrix *bias           = gsl_matrix_calloc(NCOMP, 1);
  gsl_matrix *d_weights      = gsl_matrix_calloc(NCOMP,NCOMP);
  gsl_matrix *temp_change    = gsl_matrix_alloc(NCOMP,NCOMP);
  gsl_matrix *old_d_weights  = gsl_matrix_calloc(NCOMP,NCOMP);
  gsl_matrix *shuffled_x_white  = gsl_matrix_calloc(NCOMP,x_white->size2);
  gsl_matrix_memcpy(shuffled_x_white, x_white);
  gsl_matrix_set_identity(weights);
  gsl_matrix_set_identity(old_weights);
  double lrate = 0.005/log((double)NCOMP);
  double change=1;
  double angle_delta =0;
  size_t step = 1;
  int error = 0;
  while( (step < MAX_STEP) && (change > W_STOP)){
    error = w_update(weights, x_white, bias,
      shuffled_x_white, p, r, lrate);
    if (error==1 || error==2){
      // It blowed up! RESTART!
      step = 1;
      // change = 1;
      error = 0;
      lrate *= ANNEAL;
      gsl_matrix_set_identity(weights);
      gsl_matrix_set_identity(old_weights);
      gsl_matrix_set_zero(d_weights);
      gsl_matrix_set_zero(old_d_weights);
      gsl_matrix_set_zero(bias);

      if (lrate > MIN_LRATE){
        printf("\nLowering learning rate to %g and starting again.\n",lrate);
      }
      else{
        printf("\nMatrix may not be invertible");
      }
    }
    else if (error==0){
      gsl_matrix_memcpy(d_weights, weights);
      gsl_matrix_sub(d_weights, old_weights);
      change = matrix_norm(d_weights);

      if (step > 2){
        // Compute angle delta
        gsl_matrix_memcpy(temp_change, d_weights);
        gsl_matrix_mul_elements(temp_change, old_d_weights);
        angle_delta = acos(matrix_sum(temp_change) / sqrt(matrix_norm(d_weights)*(matrix_norm(old_d_weights))));
        angle_delta *= (180.0 / M_PI);
      }

      gsl_matrix_memcpy(old_weights, weights);

      if (angle_delta > 60){
        lrate *= ANNEAL;
        gsl_matrix_memcpy(old_d_weights, d_weights);
      } else if (step==1) {
        gsl_matrix_memcpy(old_d_weights, d_weights);
      }

      if ((verbose && (step % 10)== 0) || change < W_STOP){
        printf("\nStep %zu: Lrate %.1e, Wchange %.1e, Angle %.2f",
          step, lrate, change, angle_delta);
      }

      step ++;
    }
  }

  matrix_mmul(weights, x_white, S);
  gsl_matrix_free(old_d_weights);
  gsl_matrix_free(old_weights);
  gsl_matrix_free(bias);
  gsl_matrix_free(d_weights);
  gsl_matrix_free(shuffled_x_white);
  gsl_rng_free (r);
  gsl_permutation_free (p);
}
Пример #24
0
int
main (int argc, char **argv)
{
   int   i=0, j=0, n=0, nl=0, k=0,
         posi=0, posj=0, posk=0, ncol=0, nrow=0;
   double xi=0.0, yi=0.0, yy=0.0, ei=0.0, sumsq=0.0,  med=0.0;
   gsl_matrix *X=NULL, *cov=NULL;
   gsl_vector *y=NULL, *w=NULL, *c=NULL;
   MRI_IMAGE *im = NULL;
   double *dar = NULL;
   gsl_multifit_linear_workspace *work=NULL;
   
   if (argc != 2)
   {
     fprintf (stderr,"usage: fitanje_1sign data > outfile\n");
     exit (-1);
   }

   /* slower than specific code you had but more convenient.
      It allows you to use all the column and row selections
      we can do with filenames. Also, keeps you fron worrying
      about dimensions. 
      The problem with your code was assuming you had 13 columns always 
      That was not the case for stat5_fitcoef. 
      OK, that was caused by a problem in the scripts. That is fixed,
      but I leave this change here anyway. 
      */
   fprintf(stderr,"Patience, reading %s... ", argv[1]);
   im = mri_read_double_1D (argv[1]);
   if (!im) {
      fprintf(stderr,"Error: Failed to read matrix data from %s\n",
                     argv[1]);
      return(-1);
   }
   ncol = im->ny;
   nrow = im->nx;
   fprintf (stderr,"Have %d cols, %d rows\nNow fitting...", ncol, nrow);
   n = ncol-3;
   /* now just get the array and kill the rest */
   dar = MRI_DOUBLE_PTR(im);
   /* make sure that pointer is set to NULL in im, or risk hell */
   mri_clear_data_pointer(im) ;
   if (im) mri_free(im); im = NULL; /* now kill im */
   
   X = gsl_matrix_alloc (n, 5);
   y = gsl_vector_alloc (n);
     
   c = gsl_vector_alloc (5);
   cov = gsl_matrix_alloc (5, 5);
     
   for (i = 0; i < n; i++)  {
      xi = i+1;
      gsl_matrix_set (X, i, 0, 1.0);
      gsl_matrix_set (X, i, 1, xi);
      gsl_matrix_set (X, i, 2, xi*xi);

      gsl_matrix_set (X, i, 3, xi*xi*xi);
      gsl_matrix_set (X, i, 4, xi*xi*xi*xi);
      //    printf ("%lg ",xi);
    }


    /*make header
      printf ("matrvola\n");
      ZSS: By adding # to the text line, 
           I made the output file be a .1D format */
    fprintf(stdout, "#%s_0\t%s_1\t%s_2\t%s_3\t%s_4\n",
                    argv[1],argv[1],argv[1],argv[1],argv[1]);

    // go by lines - signatures
    /* pre-allocate, I think this should be just fine, 
       there should be no need to reinitialize work 
       all the time */   
    work = gsl_multifit_linear_alloc (n, 5);
    for (nl=0; nl<nrow; ++nl) {
      posi = (int)dar[nl];
      posj = (int)dar[nl+  nrow];
      posk = (int)dar[nl+2*nrow];

      for (k = 3; k < ncol; k++) {
         gsl_vector_set (y, k-3, dar[nl+k*nrow]);
      }
        
        
      gsl_multifit_linear (X, y, c, cov,
                           &sumsq, work);
    
                          
      /* printf ( "\n # best fit: Y = %g + %g X + %g X^2 +%g X^3 + %g X^4\n",
                  C(0), C(1), C(2), C(3), C(4));
         printf ("# sumsq = %g\n", sumsq); */

      fprintf (stdout,  "%11g\t%11g\t%11g\t%11g\t%11g\n", 
                        C(0), C(1), C(2), C(3), C(4)); 

      /*
      printf ("# covariance matrix:\n");
      printf ("[ %+.5e, %+.5e, %+.5e  \n",
              COV(0,0), COV(0,1), COV(0,2));
      printf ("  %+.5e, %+.5e, %+.5e  \n", 
              COV(1,0), COV(1,1), COV(1,2));
      printf ("  %+.5e, %+.5e, %+.5e ]\n", 
              COV(2,0), COV(2,1), COV(2,2));
       printf ("# chisq = %g\n", chisq);
      */
      
   }
   gsl_multifit_linear_free (work); work = NULL;
   
   free(dar); dar = NULL; /* done with input array */

    gsl_vector_free (y);
    gsl_vector_free (c);
    gsl_matrix_free (cov);
    gsl_matrix_free (X);
    //gsl_vector_free (w);
    
    fprintf (stderr,"\n");
    return 0;

}
Пример #25
0
int GMRFLib_gsl_ginv(gsl_matrix * A, double tol, int rankdef)
{
	/* 
	 * replace n x n matrix A with its generlized inverse.  if TOL > 0, use that tolerance. If rankdef is set, use that. If both are set, give an error.
	 */

	assert(A && (A->size1 == A->size2));
	
	gsl_matrix *U = GMRFLib_gsl_duplicate_matrix(A);
	gsl_matrix *V = gsl_matrix_alloc(A->size1, A->size2);
	gsl_vector *S = gsl_vector_alloc(A->size1);
	gsl_vector *work = gsl_vector_alloc(A->size1);
	
	gsl_linalg_SV_decomp(U, V, S, work);

	size_t i;
	double one = 1.0, zero = 0.0;
	double s_max = gsl_vector_get(S, 0);
	gsl_matrix *M1 = gsl_matrix_alloc(A->size1, A->size2);
	gsl_matrix *M2 = gsl_matrix_alloc(A->size1, A->size2);

	assert(!(tol > 0.0 && (rankdef >= 0 && rankdef <= (int) A->size1)));
	if (tol > 0.0){
		for(i = 0;  i < A->size1; i++){
			double s = gsl_vector_get(S, i);
			
			if (s < tol * s_max) {
				gsl_matrix_set(M2, i, i, 0.0);
			} else {
				gsl_matrix_set(M2, i, i, 1.0/s);
			}
		}
	} else {
		assert(rankdef >= 0);
		assert(rankdef <= (int)A->size1);

		double first = gsl_vector_get(S, 0);
		double last = gsl_vector_get(S, A->size1-1);

		for(i = 0;  i < A->size1; i++){
			double s = gsl_vector_get(S, i);
			
			if (first > last){
				// do not use the last 'rdef's
				if (i < (int) A->size1 - rankdef){
					gsl_matrix_set(M2, i, i, 1.0/s);
				} else {
					gsl_matrix_set(M2, i, i, 0.0);
				}
			} else {
				// do not use the first 'rdef's
				if (i < rankdef){
					gsl_matrix_set(M2, i, i, 0.0);
				} else {
					gsl_matrix_set(M2, i, i, 1.0/s);
				}
			}
		}
	}
	
	gsl_blas_dgemm(CblasNoTrans, CblasTrans, one, M2, U, zero, M1);
	gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, one, V, M1, zero, M2);
	gsl_matrix_memcpy(A, M2);

	gsl_matrix_free(U);
	gsl_matrix_free(V);
	gsl_matrix_free(M1);
	gsl_matrix_free(M2);
	gsl_vector_free(S);
	gsl_vector_free(work);

	return GMRFLib_SUCCESS;
}
Пример #26
0
// destructor
Matrix::~Matrix()
{
    if ( data ) gsl_matrix_free( data );	
}
Пример #27
0
void checkSLE(const gsl_matrix* A, const gsl_vector* x, 
              const gsl_vector* b, const int N) {
//	TODO - make complete logging to the file
//	print("Checking the solution of the SLE ... ");

	// Checking on condition number of matrix A
	int signum;
	gsl_permutation *perm = gsl_permutation_alloc(N);
	gsl_matrix *LU = gsl_matrix_alloc(N, N);
	gsl_matrix *invA = gsl_matrix_alloc(N, N);
	gsl_matrix_memcpy(LU, A);
	gsl_linalg_LU_decomp(LU, perm, &signum);
	gsl_linalg_LU_invert(LU, perm, invA);
	gsl_matrix_free(LU);
	gsl_permutation_free(perm);
	gsl_vector *row = gsl_vector_alloc(N);
	double normA = 0;
	double normInvA = 0;
	for(int i = 0; i < N; i++) {
		gsl_matrix_get_row(row, A, i);
		double dasum = gsl_blas_dasum(row);
		if (dasum > normA) normA = dasum;
		gsl_matrix_get_row(row, invA, i);
		dasum = gsl_blas_dasum(row);
		if (dasum > normInvA) normInvA = dasum;
	}
	double conditionNumber = normA * normInvA;
	if (conditionNumber > 1000)
		//print("Condition number of matrix of SLE is ", conditionNumber);
	gsl_vector_free(row);
	
	// Checking on Ax == b
	gsl_vector *tmp = gsl_vector_alloc(N);
	gsl_vector_memcpy(tmp, b);
	// tmp = A*x - b, i.e. error
	gsl_blas_dgemv(CblasNoTrans, 1, A, x, -1, tmp);
	for(int i = 0; i < N; i++) {
		if (fabs(gsl_vector_get(tmp, i) / gsl_vector_get(b, i)) > 1e-8) {
			if (gsl_vector_get(b, i) == 0) {
				if (fabs(gsl_vector_get(tmp, i)) > 1e-8)
					print("Ax =", gsl_vector_get(tmp, i), "at string", i,
					      ". But b = 0 here.");
			} else {
				print("( Ax - b ) / b =", 
				      gsl_vector_get(tmp, i) / gsl_vector_get(b, i),
				      "at string", i);
			}
		}
	}
	
	// Checking on inv(A)b == x
	gsl_vector_memcpy(tmp, x);
	// tmp = inv(A)*b - x, i.e. error
	gsl_blas_dgemv(CblasNoTrans, 1, invA, b, -1, tmp);
	for(int i = 0; i < N; i++) {
		if (fabs(gsl_vector_get(tmp, i) / gsl_vector_get(x, i)) > 1e-8)
			print("( inv(A)b - x ) / x =",
			      gsl_vector_get(tmp, i) / gsl_vector_get(x, i),
			      "at string ", i);
	}
	
	gsl_vector_free(tmp);
	gsl_matrix_free(invA);
	
//	TODO - make complete logging to the file	
//	print("Checking is done.");
}
Пример #28
0
            /* coefficients as well */
double  singleChi(const double *sampletimes, const float *vals, const float *stderrs, 
                long ndata, long nharmonics, double tstart,
                double frequency, float *harmoniccoeffs)
{
#define MAXHARM 17
    int i, j, d;
    int result;
    double  alpha[2*MAXHARM+1][2*MAXHARM+1];
    double  beta[2*MAXHARM+1];
    double chisqred;

    gsl_matrix *alpha_gsl = gsl_matrix_alloc(2 * nharmonics + 1,2 * nharmonics + 1);
    gsl_vector *beta_gsl =  gsl_vector_alloc(2 * nharmonics + 1);
    gsl_vector *x_gsl    =  gsl_vector_alloc(2 * nharmonics + 1);

    assert(nharmonics <= MAXHARM);

    for (i = 0 ; i < 2*nharmonics+1 ; i++)
    {
        beta[i] = 0;
        for (j = 0 ; j < 2*nharmonics+1 ; j++)
            alpha[i][j] = 0;
    }

    for (d = 0 ; d < ndata ; d++)
    {
        for (i = 0 ; i < 2*nharmonics+1 ; i++)
        {
            double invvar = 1/(stderrs[d] * stderrs[d]);
            beta[i] += vals[d] 
                    * invvar 
                    * Mfunc(i, (sampletimes[d] - tstart) * frequency * 2 * M_PI);
            for (j = 0 ; j < 2*nharmonics+1 ; j++)
                alpha[i][j] += invvar 
                            * Mfunc(i, (sampletimes[d] - tstart) * frequency * 2 * M_PI)
                            * Mfunc(j, (sampletimes[d] - tstart) * frequency * 2 * M_PI);
        }
    }    

    for (i = 0 ; i < 2*nharmonics+1 ; i++)
    {
        gsl_vector_set(beta_gsl, i, beta[i]);
        for (j = 0 ; j < 2*nharmonics+1 ; j++)
            gsl_matrix_set(alpha_gsl, i, j, alpha[i][j]);
    }

    result = gsl_linalg_HH_solve(alpha_gsl, beta_gsl, x_gsl);
            /* x = alpha^-1 beta */
    assert(result == 0);
    gsl_blas_ddot(x_gsl, beta_gsl, &chisqred);

    if (harmoniccoeffs)
    {
        for (i = 0 ; i < 2*nharmonics+1 ; i++)
        {
            harmoniccoeffs[i] = gsl_vector_get(x_gsl, i);
        }
    }
    
    gsl_matrix_free(alpha_gsl);
    gsl_vector_free(beta_gsl);
    gsl_vector_free(x_gsl);

    return chisqred;
}
Пример #29
0
// [[Rcpp::export]]
Rcpp::List fitData(Rcpp::DataFrame ds) {

    const size_t ncoeffs = NCOEFFS;
    const size_t nbreak = NBREAK;

    const size_t n = N;
    size_t i, j;

    Rcpp::DataFrame D(ds);    		// construct the data.frame object
    RcppGSL::vector<double> y = D["y"];	// access columns by name, 
    RcppGSL::vector<double> x = D["x"];	// assigning to GSL vectors
    RcppGSL::vector<double> w = D["w"];

    gsl_bspline_workspace *bw;
    gsl_vector *B;
    gsl_vector *c; 
    gsl_matrix *X, *cov;
    gsl_multifit_linear_workspace *mw;
    double chisq, Rsq, dof, tss;

    bw = gsl_bspline_alloc(4, nbreak);	    // allocate a cubic bspline workspace (k = 4)
    B = gsl_vector_alloc(ncoeffs);

    X = gsl_matrix_alloc(n, ncoeffs);
    c = gsl_vector_alloc(ncoeffs);
    cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
    mw = gsl_multifit_linear_alloc(n, ncoeffs);

    gsl_bspline_knots_uniform(0.0, 15.0, bw);	// use uniform breakpoints on [0, 15] 

    for (i = 0; i < n; ++i) {			// construct the fit matrix X 
        double xi = gsl_vector_get(x, i);

        gsl_bspline_eval(xi, B, bw);		// compute B_j(xi) for all j 

        for (j = 0; j < ncoeffs; ++j) {		// fill in row i of X 
            double Bj = gsl_vector_get(B, j);
            gsl_matrix_set(X, i, j, Bj);
        }
    }

    gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw);  // do the fit 
    
    dof = n - ncoeffs;
    tss = gsl_stats_wtss(w->data, 1, y->data, 1, y->size);
    Rsq = 1.0 - chisq / tss;
    
    Rcpp::NumericVector FX(151), FY(151);	// output the smoothed curve 
    double xi, yi, yerr;
    for (xi = 0.0, i=0; xi < 15.0; xi += 0.1, i++) {
        gsl_bspline_eval(xi, B, bw);
        gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
        FX[i] = xi;
        FY[i] = yi;
    }

    Rcpp::List res =
      Rcpp::List::create(Rcpp::Named("X")=FX,
                         Rcpp::Named("Y")=FY,
			 Rcpp::Named("chisqdof")=Rcpp::wrap(chisq/dof),
			 Rcpp::Named("rsq")=Rcpp::wrap(Rsq));

    gsl_bspline_free(bw);
    gsl_vector_free(B);
    gsl_matrix_free(X);
    gsl_vector_free(c);
    gsl_matrix_free(cov);
    gsl_multifit_linear_free(mw);
    
    y.free();
    x.free();
    w.free();

    return(res);   
}
Пример #30
0
void freeParam(parameters *param)
{
    gsl_matrix_free(param->beta);

    free(param);
}