Exemple #1
0
int
main (void)
{
  gsl_ieee_env_setup();

  test_longley();
  test_filip();
  test_pontius();

  {
    gsl_multifit_function_fdf f = make_fdf (&brown_f, &brown_df, &brown_fdf,
                                            brown_N, brown_P, 0);
    
    test_lmder(&f, brown_x0, &brown_X[0][0], brown_F, &brown_cov[0][0]);
  }

  {
    gsl_multifit_function_fdf f = make_fdf (&enso_f, &enso_df, &enso_fdf,
                                            enso_N, enso_P, 0);

    test_fdf("nist-ENSO", &f, enso_x0, enso_x, enso_sumsq, enso_sigma);
  }

  {
    gsl_multifit_function_fdf f = make_fdf (&kirby2_f, &kirby2_df, &kirby2_fdf,
                                            kirby2_N, kirby2_P, 0);

    test_fdf("nist-kirby2", &f, kirby2_x0, kirby2_x, kirby2_sumsq, kirby2_sigma);
  }

  {
    gsl_multifit_function_fdf f = make_fdf (&hahn1_f, &hahn1_df, &hahn1_fdf,
                                            hahn1_N, hahn1_P, 0);

    test_fdf("nist-hahn1", &f, hahn1_x0, hahn1_x, hahn1_sumsq, hahn1_sigma);
  }

#ifdef JUNK
  {
    gsl_multifit_function_fdf f = make_fdf (&nelson_f, &nelson_df, &nelson_fdf,
                                            nelson_N, nelson_P, 0);

    test_fdf("nist-nelson", &f, nelson_x0, nelson_x, nelson_sumsq, nelson_sigma);
  }
#endif

  /* now summarize the results */

  exit (gsl_test_summary ());
}
Exemple #2
0
		void FitModel::train()
		{	
			if (descriptor_matrix_.cols() == 0)
			{
				throw Exception::InconsistentUsage(__FILE__, __LINE__, "Data must be read into the model before training!"); 
			}
			if (allEquations_.empty())
			{
				cout<<"ERROR: No equations specified! Use method setEquations first."<<endl; 
				return;
			}
				
			training_result_.resize(descriptor_matrix_.cols(), Y_.cols());
			
			for (c = 0; c < (unsigned int)Y_.cols(); c++)
			{	
 				fitY = new Eigen::MatrixXd(Y_.rows(), 1);
				for (int n = 0; n < Y_.rows(); n++)
				{
					(*fitY)(n, 0) = Y_(n, c);
				}
				
				fitX = &descriptor_matrix_;
				equation = &allEquations_[c];
				
				if (allDiffEquations_.size() < c)
				{
					diffEquations = &allDiffEquations_[c]; 
				}
				else
				{
					diffEquations = NULL; 
				}
					
				const gsl_multifit_fdfsolver_type* T = gsl_multifit_fdfsolver_lmsder; 
				gsl_multifit_fdfsolver* s = gsl_multifit_fdfsolver_alloc(T, fitX->rows(), fitX->cols()); 
				
				const size_t n = descriptor_matrix_.rows();
				const size_t p = descriptor_matrix_.cols();
				gsl_multifit_function_fdf fdf; 
						
				fdf = make_fdf(&setF, &setDf, &setFdf, n, p, 0);
				
				double* g = new double[initial_guess_.size()];
				for (unsigned int m = 0; m < initial_guess_.size(); m++)
				{
					g[m] = initial_guess_[m];
				}
				
				gsl_vector_view ini = gsl_vector_view_array (g, p);
				
				gsl_multifit_fdfsolver_set(s, &fdf, &ini.vector); 
			
				int status;
				
				for (unsigned int i = 0; i < 50; i++)
				{
					status = gsl_multifit_fdfsolver_iterate(s); 
				}
				
				// save the predicted coefficients
				for (unsigned int m = 0; m < s->x->size; m++)
				{
					training_result_(m, c) = gsl_vector_get(s->x, m);
				}
				
				delete fitY;
				delete [] g;
				gsl_multifit_fdfsolver_free(s); 
			}
			cout <<training_result_<<endl;
		}