Beispiel #1
0
void ica(gsl_matrix *A, gsl_matrix *S, gsl_matrix *X, int verbose){

  /* Checking the existance of the enviroment variable
  for controlling the number of threads used by openblas*/


  const size_t NCOMP = A->size2;
  const size_t NSUB = X->size1;
  const size_t NVOX = X->size2;
  gsl_matrix *weights = gsl_matrix_alloc(NCOMP, NCOMP);
  gsl_matrix *inv_weights = gsl_matrix_alloc(NCOMP, NCOMP);
  gsl_matrix *white_X = gsl_matrix_alloc(NCOMP, NVOX);
  gsl_matrix *white   = gsl_matrix_alloc(NCOMP, NSUB);
  gsl_matrix *dewhite = gsl_matrix_alloc(NSUB, NCOMP);


  pca_whiten(X, NCOMP, white_X, white, dewhite, 1);


  if (verbose) printf("Done.");
  if (verbose) printf("\nINFOMAX ...");
  if (verbose) printf("\nPCA decomposition ...");
  infomax(white_X, weights, S, verbose);
  if (verbose) printf("Done");

  matrix_inv(weights, inv_weights);
  matrix_mmul(dewhite, inv_weights, A);

  gsl_matrix_free(weights);
  gsl_matrix_free(white_X);
  gsl_matrix_free(white);
  gsl_matrix_free(dewhite);

}
Beispiel #2
0
void rotator::update(float elapsed_seconds)
{
    glm::mat4 matrix(1.0f);
    matrix = glm::translate(matrix, glm::vec3(0, 0, dist_));
    matrix = glm::rotate(matrix, angle_x_, glm::vec3(1, 0, 0));
    matrix = glm::rotate(matrix, angle_y_, glm::vec3(0, 1, 0));
    scene_->update_modelview(matrix);

    glm::mat4 matrix_inv(1.0f);
    matrix_inv = glm::rotate(matrix_inv, -angle_y_, glm::vec3(0, 1, 0));
    matrix_inv = glm::rotate(matrix_inv, -angle_x_, glm::vec3(1, 0, 0));
    matrix_inv = glm::translate(matrix_inv, glm::vec3(0, 0, -dist_));
    scene_->update_modelview_inv(matrix_inv);
    scene_->update(elapsed_seconds);
}
Beispiel #3
0
int main( int argc, char ** argv)  {
  rng_type * rng   =  rng_alloc( MZRAN , INIT_DEV_RANDOM );
  matrix_type * A  =  matrix_alloc( 12 , 12 );
  matrix_type * B  =  matrix_alloc( 12 , 12 );
  matrix_random_init( A , rng );
  matrix_assign( B , A );
  matrix_pretty_print( A , "    A " , "%8.4f" );
  

#ifdef WITH_LAPACK
  matrix_inv( B );
  printf("\n");
  matrix_pretty_print( B , "inv(A)" , "%8.4f" );
  matrix_inplace_matmul( B , A );
  printf("\n");
  matrix_pretty_print( B , "    I " , "%8.4f" );
  {
    matrix_type * A3 = matrix_alloc(3,3);
    matrix_random_init( A3 , rng );
    matrix_iset( A3 , 0 , 0 , sin(0.98));
    printf("matrix_det3:%g  ",matrix_det3( A3 ));
    printf("matrix_det:%g \n",matrix_det( A3 ));
  }

  {
    matrix_type * A4 = matrix_alloc(4,4);
    matrix_random_init( A4 , rng );
    matrix_iset( A4 , 0 , 0 , sin(0.98));
    printf("matrix_det4:%g  ",matrix_det4( A4 ));
    printf("matrix_det:%g \n",matrix_det( A4 ));
  }
#endif

  matrix_free( A );
  matrix_free( B );
  rng_free( rng );
}
Beispiel #4
0
void lars_estimate(lars_type * lars , int max_vars , double max_beta , bool verbose) {
  int nvars       = matrix_get_columns( lars->X );
  int nsample     = matrix_get_rows( lars->X );
  matrix_type * X = matrix_alloc( nsample, nvars );    // Allocate local X and Y variables
  matrix_type * Y = matrix_alloc( nsample, 1 );        // which will hold the normalized data 
  lars_estimate_init( lars , X , Y);                   // during the estimation process.
  {
    matrix_type * G                = matrix_alloc_gram( X , true );
    matrix_type * mu               = matrix_alloc( nsample , 1 );
    matrix_type * C                = matrix_alloc( nvars , 1 );
    matrix_type * Y_mu             = matrix_alloc_copy( Y ); 
    int_vector_type * active_set   = int_vector_alloc(0,0);
    int_vector_type * inactive_set = int_vector_alloc(0,0);
    int    active_size;

    
    if ((max_vars <= 0) || (max_vars > nvars))
      max_vars = nvars;
    
    {
      int i;
      for (i=0; i < nvars; i++)
        int_vector_iset( inactive_set , i , i );
    }
    matrix_set( mu , 0 );

    while (true) {
      double maxC = 0;

      /*
        The first step is to calculate the correlations between the
        covariates, and the current residual. All the currently inactive
        covariates are searched; the covariate with the greatest
        correlation with (Y - mu) is selected and added to the active set.
      */
      matrix_sub( Y_mu , Y , mu );                            // Y_mu = Y - mu 
      matrix_dgemm( C , X , Y_mu , true , false , 1.0 , 0);   // C    = X' * Y_mu
      { 
        int i;
        int max_set_index = 0;

        for (i=0; i < int_vector_size( inactive_set ); i++) {
          int    set_index = i;
          int    var_index = int_vector_iget( inactive_set , set_index );
          double value     = fabs( matrix_iget(C ,  var_index , 0) );
          if (value > maxC) {
            maxC          = value;
            max_set_index = set_index;
          }
        }
        /* 
           Remove element corresponding to max_set_index from the
           inactive set and add it to the active set:
        */
        int_vector_append( active_set , int_vector_idel( inactive_set , max_set_index ));
      }
      active_size = int_vector_size( active_set );
      /*
        Now we have calculated the correlations between all the
        covariates and the current residual @Y_mu. The correlations are
        stored in the matrix @C. The value of the maximum correlation is
        stored in @maxC.
      
        Based on the value of @maxC we have added one new covariate to
        the model, technically by moving the index from @inactive_set to
        @active_set.
      */

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


      {
        matrix_type * weights     = matrix_alloc( active_size , 1);
        double scale;

        /*****************************************************************/
        /* This scope should compute and initialize the variables
           @weights and @scale. */
        {
          matrix_type * subG        = matrix_alloc( active_size , active_size );
          matrix_type * STS         = matrix_alloc( active_size , active_size );
          matrix_type * sign_vector = matrix_alloc( active_size , 1);
          int i , j;

          /*
            STS = S' o S where 'o' is the Schur product and S is given
            by:

            [  s1   s2   s3   s4 ]  
        S = [  s1   s2   s3   s4 ]
            [  s1   s2   s3   s4 ]
            [  s1   s2   s3   s4 ]

            Where si is the sign of the correlation between (active)
            variable 'i' and Y_mu.
          */

                
          for (i=0; i < active_size ; i++) {
            int     vari  = int_vector_iget( active_set , i );
            double  signi = sgn( matrix_iget( C , vari , 0));
            matrix_iset( sign_vector , i , 0 , signi );
            for (j=0; j < active_size; j++) {
              int     varj  = int_vector_iget( active_set , j );
              double  signj = sgn( matrix_iget( C , varj , 0));
            
              matrix_iset( STS , i , j , signi * signj );
            }
          }
        
          // Extract the elements from G corresponding to active indices and
          // copy to the matrix subG:
          for (i=0; i < active_size ; i++) {
            int ii = int_vector_iget( active_set , i );
            for (j=0; j < active_size; j++) {
              int jj = int_vector_iget( active_set , j );
            
              matrix_iset( subG , i , j , matrix_iget(G , ii , jj));
            }
          }
      
          // Weights 
          matrix_inplace_mul( subG , STS );  
          matrix_inv( subG );
        
          {
            matrix_type * ones = matrix_alloc( active_size , 1 );
            matrix_type * GA1  = matrix_alloc( active_size , 1 );
          
            matrix_set( ones , 1.0 );
            matrix_matmul( GA1 , subG , ones );
            scale = 1.0 / sqrt( matrix_get_column_sum( GA1 , 0 ));
          
            matrix_mul( weights , GA1 , sign_vector );
            matrix_scale( weights , scale );
          
            matrix_free( GA1 );
            matrix_free( ones );
          }
        
          matrix_free( sign_vector );
          matrix_free( subG );
          matrix_free( STS );
        }
      
        /******************************************************************/
        /* The variables weight and scale have been calculated, proceed
           to calculate the step length @gamma. */ 
        {
          int i;
          double  gamma;
        
          {
            matrix_type * u = matrix_alloc( nsample , 1 );
            int j;

            for (i=0; i < nsample; i++) {
              double row_sum = 0;
              for (j =0; j < active_size; j++) 
                row_sum += matrix_iget( X , i , int_vector_iget( active_set , j)) * matrix_iget(weights , j , 0 );
            
              matrix_iset( u , i , 0 , row_sum );
            }
          
            gamma = maxC / scale;
            if (active_size < matrix_get_columns( X )) {
              matrix_type * equi_corr = matrix_alloc( nvars , 1 );
              matrix_dgemm( equi_corr , X , u , true , false , 1.0 , 0);     // equi_corr = X'·u
              for (i=0; i < (nvars - active_size); i++) {
                int var_index  = int_vector_iget( inactive_set , i );
                double gamma1  = (maxC - matrix_iget(C , var_index , 0 )) / ( scale - matrix_iget( equi_corr , var_index , 0));
                double gamma2  = (maxC + matrix_iget(C , var_index , 0 )) / ( scale + matrix_iget( equi_corr , var_index , 0));
              
                if ((gamma1 > 0) && (gamma1 < gamma))
                  gamma = gamma1;
              
                if ((gamma2 > 0) && (gamma2 < gamma))
                  gamma = gamma2;
              
              }
              matrix_free( equi_corr );
            }
            /* Update the current estimated 'location' mu. */
            matrix_scale( u , gamma );
            matrix_inplace_add( mu , u );
            matrix_free( u );
          } 
      
          /* 
             We have calculated the step length @gamma, and the @weights. Update the @beta matrix.
          */
          for (i=0; i < active_size; i++) 
            matrix_iset( lars->beta , int_vector_iget( active_set , i ) , active_size - 1 , gamma * matrix_iget( weights , i , 0));
      
          if (active_size > 1) 
            for (i=0; i < nvars; i++)
              matrix_iadd( lars->beta , i , active_size - 1 , matrix_iget( lars->beta , i , active_size - 2)); 
        
          matrix_free( weights );
        }
      }
    
      if (active_size == max_vars)
        break;
      
      if (max_beta > 0) {
        double beta_norm2 = matrix_get_column_abssum( lars->beta , active_size - 1 );
        if (beta_norm2 > max_beta) {
          // We stop - we will use an interpolation between this beta estimate and
          // the previous, to ensure that the |beta| = max_beta criteria is satisfied.
          if (active_size >= 2) {
            double beta_norm1 = matrix_get_column_abssum( lars->beta , active_size - 2 );
            double s = (max_beta - beta_norm1)/(beta_norm2 - beta_norm1);
            {
              int j;
              for (j=0; j < nvars; j++) {
                double beta1 = matrix_iget( lars->beta , j , active_size - 2 );
                double beta2 = matrix_iget( lars->beta , j , active_size - 1 );
                matrix_iset( lars->beta , j , active_size - 1 , beta1 + s*(beta2 - beta1));
              }
            }
          }
          break;
        }
      }
    }
    matrix_free( G );
    matrix_free( mu );
    matrix_free( C );
    matrix_free( Y_mu );
    int_vector_free( active_set );
    int_vector_free( inactive_set );
    matrix_resize( lars->beta , nvars , active_size , true );
    if (verbose) 
      matrix_pretty_fprint( lars->beta , "beta" , "%12.5f" , stdout );
    lars_select_beta( lars , active_size - 1);
  }
  matrix_free( X );
  matrix_free( Y );
}
Beispiel #5
0
Datei: cox.c Projekt: CharoL/math
void cox_test(double** covariates, size_t num_features_in_covariate, size_t num_samples, double* time, double* censor, double* coefficients, double** variance) {
    // declare variables, init values and allocate memory
    // gsl matrices
    matrix_t* coefficients_matrix_p =  NULL;
    matrix_t* information_matrix_p =  NULL;
    matrix_t* information_matrix_inverse_p =  NULL;
    matrix_t* score_matrix_p =  NULL;
    matrix_t* error_matrix_p =  NULL;
    matrix_t* variance_matrix_p =  NULL;

    // other variables
    double denominator = 0, numerator = 0;
    double error1 = 1, error2 = 1;
    double* risk_factor = (double*) calloc(num_samples, sizeof(double));
    double* score = (double*) calloc(num_features_in_covariate, sizeof(double));
    double** expected_covariate = (double**) calloc(num_features_in_covariate, sizeof(double*));
    double** information = (double**) calloc(num_features_in_covariate, sizeof(double*));
    
    for (size_t i = 0; i < num_features_in_covariate; i++) {
        coefficients[i] = 0.1;
        expected_covariate[i] = (double*) calloc(num_samples, sizeof(double));
        information[i] = (double*) calloc(num_features_in_covariate, sizeof(double));
    }

    // create gsl matrices
    coefficients_matrix_p =  matrix_new(num_features_in_covariate, 1);
    matrix_init(0.1, coefficients_matrix_p);
    information_matrix_p = matrix_new(num_features_in_covariate, num_features_in_covariate);
    score_matrix_p = matrix_new(num_features_in_covariate, 1);
    error_matrix_p = matrix_new(num_features_in_covariate, 1);
    information_matrix_inverse_p = matrix_new(num_features_in_covariate, num_features_in_covariate);

    while((error1 > COX_ERROR_LIMIT) || (error2 > COX_ERROR_LIMIT)) {
        for (size_t i = 0; i < num_samples; ++i) {
            risk_factor[i] = 1.0;
            for (size_t s = 0; s < num_features_in_covariate; ++s) {
                risk_factor[i] *= exp(coefficients[s] * covariates[s][i]);
            }
        }

        for (size_t j = 0; j < num_features_in_covariate; j++) {
            score[j] = 0.0;
            for (size_t i = 0; i < num_samples; i++) {
                for (size_t k = 0; k < num_samples; k++) {
                    if (time[k] >= time[i]) {
                        denominator += risk_factor[k];
                        numerator += covariates[j][k] * risk_factor[k];
                    }
                }
                 
                expected_covariate[j][i] = numerator / denominator;
                score[j] += censor[i] * (covariates[j][i] - expected_covariate[j][i]);

                numerator = 0.0;
                denominator = 0.0;
            }
        }

        for (size_t r = 0; r < num_features_in_covariate; r++) {
            for (size_t s = 0; s < num_features_in_covariate; s++) {
                information[r][s] = 0.0;
                for (size_t i = 0; i < num_samples; i++) {
                    for (size_t k = 0; k < num_samples; k++) {
                        if (time[k] >= time[i]) {
                            denominator += risk_factor[k];
                            numerator += (covariates[r][k] * covariates[s][k] * risk_factor[k]);
                        }
                    }
                    information[r][s] +=  censor[i] * (expected_covariate[r][i] * expected_covariate[s][i] - (numerator / denominator));

                    numerator = 0.0;
                    denominator = 0.0;
                }
            }
        }

        // fill information_matrix
        matrix_fill(information, num_features_in_covariate, num_features_in_covariate, information_matrix_p);  // fill the matrix with data

        // fill score_matrix from score array
        for (size_t i = 0; i < num_features_in_covariate; i++) {
            matrix_set(i, 0, score[i], score_matrix_p);
        }

        // calculate error matrix: inv(information_matrix) * score_matrix
        matrix_inv(information_matrix_p, information_matrix_inverse_p);
        matrix_mul(information_matrix_inverse_p, score_matrix_p, error_matrix_p);

        // calculate coefficients matrix
        coefficients_matrix_p = matrix_sub(coefficients_matrix_p, error_matrix_p);

        // fill coefficientes
        for (size_t i = 0; i < num_features_in_covariate; i++) {
            coefficients[i] = matrix_get(i, 0, coefficients_matrix_p);
        }

        error1 = sqrt(matrix_Fnorm(error_matrix_p));
        error2 = sqrt(matrix_Fnorm(score_matrix_p));
    }  // end of while
    
    // calculate variance: (-1 * inv(information_matrix))
    variance_matrix_p = matrix_scale(information_matrix_inverse_p, -1.0);
    for (size_t i = 0; i < num_features_in_covariate; i++) {
        for (size_t j = 0; j < num_features_in_covariate; j++) {
            variance[i][j] = matrix_get(i, j, variance_matrix_p);
        }
    }  

    // free gsl matrices
    matrix_free(coefficients_matrix_p);
    matrix_free(information_matrix_p);
    matrix_free(information_matrix_inverse_p);
    matrix_free(score_matrix_p);
    matrix_free(error_matrix_p);
    variance_matrix_p = NULL;  // points to information_matrix_inverse_p previously freed
    matrix_free(variance_matrix_p); 

    // free other resources
    free(risk_factor);
    free(score);
    for (size_t i = 0; i < num_features_in_covariate; i++) {
        free(expected_covariate[i]);
        free(information[i]);
    }    
    free(expected_covariate);
    free(information); 
    
    return;
}