void Classemes_end()
{
delete_matrix(Tau);
free(Tau);
delete_matrix(Phi);
free(Phi);
}
void pred_generic(const unsigned int n, const double phidf, double *Z,
double **Ki, const unsigned int nn, double **k, double *mean, double **Sigma)
{
int i, j;
double **ktKi, **ktKik;
/* ktKi <- t(k) %*% util$Ki */
ktKi = new_matrix(n, nn);
linalg_dsymm(CblasRight,nn,n,1.0,Ki,n,k,nn,0.0,ktKi,nn);
/* ktKik <- ktKi %*% k */
ktKik = new_matrix(nn, nn);
linalg_dgemm(CblasNoTrans,CblasTrans,nn,nn,n,
1.0,k,nn,ktKi,nn,0.0,ktKik,nn);
/* mean <- ktKi %*% Z */
linalg_dgemv(CblasNoTrans,nn,n,1.0,ktKi,nn,Z,1,0.0,mean,1);
/* Sigma <- phi*(Sigma - ktKik)/df */
for(i=0; i<nn; i++) {
Sigma[i][i] = phidf * (Sigma[i][i] - ktKik[i][i]);
for(j=0; j<i; j++)
Sigma[j][i] = Sigma[i][j] = phidf * (Sigma[i][j] - ktKik[i][j]);
}
/* clean up */
delete_matrix(ktKi);
delete_matrix(ktKik);
}
/** delete local problem */
void fclib_delete_local (struct fclib_local *problem)
{
delete_matrix (problem->W);
delete_matrix (problem->V);
delete_matrix (problem->R);
free (problem->mu);
free (problem->q);
if (problem->s) free (problem->s);
delete_info (problem->info);
}
int main(int argc, char** argv)
{
int matrix_size;
int silent = 0;
int optchar;
elem_t *a, *inv, *prod;
elem_t eps;
double error;
double ratio;
while ((optchar = getopt(argc, argv, "qt:")) != EOF)
{
switch (optchar)
{
case 'q': silent = 1; break;
case 't': s_nthread = atoi(optarg); break;
default:
fprintf(stderr, "Error: unknown option '%c'.\n", optchar);
return 1;
}
}
if (optind + 1 != argc)
{
fprintf(stderr, "Error: wrong number of arguments.\n");
}
matrix_size = atoi(argv[optind]);
/* Error checking. */
assert(matrix_size >= 1);
assert(s_nthread >= 1);
eps = epsilon();
a = new_matrix(matrix_size, matrix_size);
init_matrix(a, matrix_size, matrix_size);
inv = invert_matrix(a, matrix_size);
prod = multiply_matrices(a, matrix_size, matrix_size,
inv, matrix_size, matrix_size);
error = identity_error(prod, matrix_size);
ratio = error / (eps * matrix_size);
if (! silent)
{
printf("error = %g; epsilon = %g; error / (epsilon * n) = %g\n",
error, eps, ratio);
}
if (isfinite(ratio) && ratio < 100)
printf("Error within bounds.\n");
else
printf("Error out of bounds.\n");
delete_matrix(prod);
delete_matrix(inv);
delete_matrix(a);
return 0;
}
/* ----------------------------- MNI Header -----------------------------------
@NAME : delete_lambda_buffer
@INPUT : lambda_buffer - pointer to buffers used to calculate smoothness
of output fields for glim_image
@OUTPUT : nothing
@RETURNS :
@DESCRIPTION: routine to delete buffers used for calculating
smoothness of field
@CREATED : Nov. 3, 1997, J. Taylor
@MODIFIED :
---------------------------------------------------------------------------- */
int delete_lambda_buffer(Lambda *lambda_buffer)
{
int ibuff, itest;
Fwhm_Info *fwhm_general;
GI_FREE(lambda_buffer->sizes);
GI_FREE(lambda_buffer->coord);
GI_FREE(lambda_buffer->step);
GI_FREE(lambda_buffer->test);
if(lambda_buffer->is_gaussian == FALSE) {
for(itest=0; itest<lambda_buffer->num_test; itest++) {
fwhm_general = lambda_buffer->fwhm_general[itest];
for(ibuff=0; ibuff<lambda_buffer->num_buffers; ibuff++) {
GI_FREE(fwhm_general->data[ibuff]);
}
GI_FREE(fwhm_general->data);
delete_matrix(fwhm_general->lambda);
GI_FREE(fwhm_general->deriv);
}
if (lambda_buffer->fwhm_simple != NULL) {
GI_FREE(lambda_buffer->fwhm_simple->deriv);
for(ibuff=0; ibuff<lambda_buffer->num_buffers; ibuff++) {
GI_FREE(lambda_buffer->fwhm_simple->data[ibuff]);
}
GI_FREE(lambda_buffer->fwhm_simple->data);
delete_matrix(lambda_buffer->fwhm_simple->lambda);
}
}
else if (lambda_buffer->fwhm_gaussian != NULL) {
GI_FREE(lambda_buffer->fwhm_gaussian->deriv);
for(ibuff=0; ibuff<lambda_buffer->num_buffers; ibuff++) {
GI_FREE(lambda_buffer->fwhm_gaussian->data[ibuff]);
}
GI_FREE(lambda_buffer->fwhm_gaussian->data);
delete_matrix(lambda_buffer->fwhm_gaussian->lambda);
}
if(lambda_buffer->is_avg == TRUE) {
GI_FREE(lambda_buffer->fwhm_avg->deriv);
for(ibuff=0; ibuff<lambda_buffer->num_buffers; ibuff++) {
GI_FREE(lambda_buffer->fwhm_avg->data[ibuff]);
}
GI_FREE(lambda_buffer->fwhm_avg->data);
delete_matrix(lambda_buffer->fwhm_avg->lambda);
}
return TRUE;
}
double * Linear_Regression::find_coeff_for_linear_regress(std::vector<Abalone> &Abalones)
{
int number_of_features = 8;
std::vector<double *> arr;
for (Abalone a : Abalones)
{
double *tmp = new double[number_of_features + 1];
double s = 1;
if (a.get_Sex() == 'I'){ s = 2; }
else if (a.get_Sex() == 'F'){ s = 3; }
tmp[0] = s; tmp[1] = a.get_Diameter(); tmp[2] = a.get_Height(); tmp[3] = a.get_Length(); tmp[4] = a.get_Shell_weight();
tmp[5] = a.get_Shucked_weight(); tmp[6] = a.get_Viscera_weight(); tmp[7] = a.get_Whole_weight(); tmp[8] = a.get_Rings();
arr.push_back(tmp);
}
double ** F = new double*[number_of_features];
double ** B = new double*[number_of_features];
for (int i = 0; i < number_of_features; i++)
{
F[i] = new double[number_of_features];
B[i] = new double[1];
B[i][0] = 0;
for (int h = 0; h < arr.size(); h++)
{
B[i][0] += arr[h][number_of_features] * arr[h][i];
}
for (int j = 0; j < number_of_features; j++)
{
F[i][j] = 0;
for (int h = 0; h < arr.size(); h++)
{
F[i][j] += arr[h][j] * arr[h][i];
}
}
}
double ** F_inverse = inverse(F, number_of_features);
double ** alpha = multiply(F_inverse, B, number_of_features, number_of_features, 1);
double * res = new double[number_of_features];
for (int i = 0; i < number_of_features; i++)
{
res[i] = alpha[i][0];
}
for (int h = 0; h < arr.size(); h++)
{
delete arr[h];
}
arr.clear();
delete_matrix(F, number_of_features);
delete_matrix(B, number_of_features);
delete_matrix(alpha, number_of_features);
return res;
}
/** delete global problem */
void fclib_delete_global (struct fclib_global *problem)
{
delete_matrix (problem->M);
delete_matrix (problem->H);
delete_matrix (problem->G);
free (problem->mu);
free (problem->f);
if (problem->b) free (problem->b);
free (problem->w);
delete_info (problem->info);
}
void Classemes_deconstructor(Classemes* obj)
{
assert(obj);
if (obj->desc) {
delete_matrix(obj->desc);
free(obj->desc);
}
if (obj->desc_bin) {
delete_matrix(obj->desc_bin);
free(obj->desc_bin);
}
}
/*--------------------------------------------*/
void NOMAD::TGP_Model::clear(void)
{
int i;
if (_av_index)
{
delete [] _av_index;
_av_index = NULL;
}
if (_fv_index)
{
delete [] _fv_index;
_fv_index = NULL;
}
if (_X)
{
for (i = 0 ; i < _p ; ++i)
delete [] _X[i];
delete [] _X;
_X = NULL;
}
if (_XX)
{
for (i = 0 ; i < _n_XX ; ++i)
delete [] _XX[i];
delete [] _XX;
_XX = NULL;
}
if (_tgp_models)
{
int m = _bbot.size();
for (i = 0 ; i < m ; ++i)
if (_tgp_models[i])
{
delete _tgp_models[i];
}
delete [] _tgp_models;
_tgp_models = NULL;
}
if (_tgp_rect)
{
delete_matrix(_tgp_rect);
_tgp_rect = NULL;
}
_error_str.clear();
_lb.clear();
_ub.clear();
_fv.clear();
_p = _n = _n_XX = 0;
_model_computed = false;
}
void free_linear_transform(preprocessed *prep)
{
ASSERT(prep);
ASSERT(prep->matrix);
delete_fixed_matrix(prep->matrix, prep->dim);
if (prep->offset)
FREE(prep->offset);
prep->matrix = NULL;
prep->offset = NULL;
ASSERT(prep->imelda);
delete_matrix(prep->imelda, prep->dim);
prep->imelda = NULL;
ASSERT(prep->invmat);
ASSERT(prep->inverse);
delete_fixed_matrix(prep->invmat, prep->dim);
delete_matrix(prep->inverse, prep->dim);
prep->invmat = NULL;
prep->inverse = NULL;
return;
}
/** Matrix inversion via the Gauss-Jordan algorithm. */
static elem_t* invert_matrix(const elem_t* const a, const int n)
{
int i, j;
elem_t* const inv = new_matrix(n, n);
elem_t* const tmp = new_matrix(n, 2*n);
copy_matrix(a, n, n, 0, n, 0, n, tmp, n, 2 * n, 0, n, 0, n);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
tmp[i * 2 * n + n + j] = (i == j);
gj(tmp, n, 2*n);
copy_matrix(tmp, n, 2*n, 0, n, n, 2*n, inv, n, n, 0, n, 0, n);
delete_matrix(tmp);
return inv;
}
int main(int argc, char** argv)
{
int matrix_size;
int silent;
elem_t *a, *inv, *prod;
elem_t eps;
double error;
double ratio;
matrix_size = (argc > 1) ? atoi(argv[1]) : 3;
s_nthread = (argc > 2) ? atoi(argv[2]) : 3;
silent = (argc > 3) ? atoi(argv[3]) : 0;
eps = epsilon();
a = new_matrix(matrix_size, matrix_size);
init_matrix(a, matrix_size, matrix_size);
inv = invert_matrix(a, matrix_size);
prod = multiply_matrices(a, matrix_size, matrix_size,
inv, matrix_size, matrix_size);
error = identity_error(prod, matrix_size);
ratio = error / (eps * matrix_size);
if (! silent)
{
printf("error = %g; epsilon = %g; error / (epsilon * n) = %g\n",
error, eps, ratio);
}
if (ratio < 100)
printf("Error within bounds.\n");
else
printf("Error out of bounds.\n");
delete_matrix(prod);
delete_matrix(inv);
delete_matrix(a);
return 0;
}
void delete_img_features(ImgFeatures* imgf)
{
unsigned int i;
assert(imgf);
for (i=0; i < imgf->n_features; ++i) {
free(imgf->name[i]);
delete_matrix(imgf->data[i]);
free(imgf->data[i]);
}
free(imgf->name);
free(imgf->level);
free(imgf->data);
}
double ssdiff(double **A, double **B, unsigned int M1,
unsigned int M2)
{
double sum;
double **C;
unsigned int i, j;
C = matrixdiff(A,B,M1,M2);
sum = 0;
for(i=0; i<M1; i++){
for(j=0; j<M2; j++){
sum= sum + C[i][j] * C[i][j];
}
}
delete_matrix(C);
return(sqrt(sum)/(M1*M2));
}
void calc_ktKikx(double *ktKik, const int m, double **k, const int n,
double *g, const double mui, double *kxy, double **Gmui_util,
double *ktGmui_util, double *ktKikx)
{
int i;
double **Gmui;
double *ktGmui;
/* first calculate Gmui = g %*% t(g)/mu */
if(!Gmui_util) Gmui = new_matrix(n, n);
else Gmui = Gmui_util;
linalg_dgemm(CblasNoTrans,CblasTrans,n,n,1,
mui,&g,n,&g,n,0.0,Gmui,n);
/* used in the for loop below */
if(!ktGmui_util) ktGmui = new_vector(n);
else ktGmui = ktGmui_util;
/* loop over all of the m candidates */
for(i=0; i<m; i++) {
/* ktGmui = drop(t(k) %*% Gmui) */
/* zerov(ktGmui, n); */
linalg_dsymv(n,1.0,Gmui,n,k[i],1,0.0,ktGmui,1);
/* ktKik += diag(t(k) %*% (g %*% t(g) * mui) %*% k) */
if(ktKik) ktKikx[i] = ktKik[i] + linalg_ddot(n, ktGmui, 1, k[i], 1);
else ktKikx[i] = linalg_ddot(n, ktGmui, 1, k[i], 1);
/* ktKik.x += + 2*diag(kxy %*% t(g) %*% k) */
ktKikx[i] += 2.0*linalg_ddot(n, k[i], 1, g, 1)*kxy[i];
/* ktKik.x + kxy^2/mui */
ktKikx[i] += sq(kxy[i])/mui;
}
/* clean up */
if(!ktGmui_util) free(ktGmui);
if(!Gmui_util) delete_matrix(Gmui);
}
double Linear_Regression::determinant(double **matrix_A, int m)
{
double det = 0;
if (m == 1)
{
return matrix_A[0][0];
}
double ***vector_matrix = new double**[m];
for (int i = 0; i < m; i++)
{
vector_matrix[i] = new double*[m - 1];
for (int j = 0; j < m - 1; j++)
{
vector_matrix[i][j] = new double[m - 1];
for (int z = 0; z < m - 1; z++)
{
if (z < i)
{
vector_matrix[i][j][z] = matrix_A[j + 1][z];
}
else
{
vector_matrix[i][j][z] = matrix_A[j + 1][z + 1];
}
}
}
}
for (int i = 0; i < m; i++)
{
det += pow(-1, i) * matrix_A[0][i] * determinant(vector_matrix[i], m - 1);
}
for (int i = 0; i < m; i++)
{
delete_matrix(vector_matrix[i], m - 1);
}
delete[] vector_matrix;
return det;
}
static void thread_main(void *args){
struct work_struct *s = args;
int tid = s->tid;
int size = s->a_1.size;
//printf("Thread %d Starting\n", tid);
switch(tid){
case 0:{
matrix temp1 = new_matrix(size);
matrix temp2 = new_matrix(size);
plus(s->a_1, s->a_2, temp1);
plus(s->b_1, s->b_2, temp2);
strassen_mult(temp1, temp2, s->c);
delete_matrix(temp2);
delete_matrix(temp1);
}
break;
case 1:{
matrix temp1 = new_matrix(size);
plus(s->a_1, s->a_2, temp1);
strassen_mult(temp1, s->b_1, s->c);
delete_matrix(temp1);
}
break;
case 2:{
matrix temp2 = new_matrix(size);
minus(s->b_1, s->b_2, temp2);
strassen_mult(s->a_1, temp2, s->c);
delete_matrix(temp2);
}
break;
case 3:{
matrix temp2 = new_matrix(size);
minus(s->b_1, s->b_2, temp2);
strassen_mult(s->a_1, temp2, s->c);
delete_matrix(temp2);
}
break;
case 4:{
matrix temp1 = new_matrix(size);
plus(s->a_1, s->a_2, temp1);
strassen_mult(temp1, s->b_1, s->c);
delete_matrix(temp1);
}
break;
case 5:{
matrix temp1 = new_matrix(size);
matrix temp2 = new_matrix(size);
minus(s->a_1, s->a_2, temp1);
plus(s->b_1, s->b_2, temp2);
strassen_mult(temp1, temp2, s->c);
delete_matrix(temp2);
delete_matrix(temp1);
}
break;
case 6:{
matrix temp1 = new_matrix(size);
matrix temp2 = new_matrix(size);
minus(s->a_1, s->a_2, temp1);
plus(s->b_1, s->b_2, temp2);
strassen_mult(temp1, temp2, s->c);
delete_matrix(temp2);
delete_matrix(temp1);
}
break;
}
}
/**
\brief destructor; needed because of dynamic allocation
*/
~ScoringMatrix() {delete_matrix(matrix, width);}
int main(void) {
// Construct a new 3x6 matrix
MATRIX a = new_matrix(3,6);
puts("Initial matrix a:");
print_matrix(&a);
puts("Modified matrix a:");
set(&a, 1, 1, 20.0);
set(&a, 2, 2, 40.0);
set(&a, 0, 4, 60.0);
set(&a, 2, 5, 80.0);
change(&a);
print_matrix(&a);
puts("Element a(2,2):");
print_value(get(&a, 2, 2));
puts("");
puts("Element a(0,4):");
print_value(get(&a, 0, 4));
puts("");
// Construct a new 6x5 matrix
MATRIX b = new_matrix(6,5);
set(&b, 0, 4, 10.0);
set(&b, 2, 3, 30.0);
set(&b, 3, 1, 50.0);
set(&b, 5, 0, 70.0);
change(&b);
puts("Matrix b:");
print_matrix(&b);
puts("");
// Construct a new 4x7 matrix
MATRIX c = new_matrix(4,7);
set(&c, 0, 1, 10.0);
set(&c, 1, 2, 10.0);
set(&c, 2, 3, 10.0);
set(&c, 3, 4, 10.0);
set(&c, 3, 5, 10.0);
set(&c, 2, 6, 10.0);
change(&c);
puts("Matrix c:");
print_matrix(&c);
puts("");
// Test matprod with a product defined case
puts("The product ab is:");
MATRIX m = matprod(&a,&b);
print_matrix(&m);
puts("");
// Test matprod with an undefined product case
puts("The product ac is:");
MATRIX n = matprod(&a,&c);
print_matrix(&n);
puts("");
// Destruct matrices when done
delete_matrix(a);
delete_matrix(b);
delete_matrix(c);
delete_matrix(m);
delete_matrix(n);
return 0;
}
main()
#endif
{
FILE *fp = stdin; /* File pointer, default stdin */
CRITICALS *tuples, *lower_dim_tuples;
int i, temp;
BOUNDARY **boundary;
CUBE *cube;
int n, num_rows, num_cols;
MATRIX matrix, tmatrix;
printf("\ncmat - version %1.2f\n\n", VERSION_NUM);
#ifndef NO_CMD_LINE
/* Check the command line and open file if required */
command_line(&fp,argc, argv, &n);
#else
/* Read command info from standard input */
command_input(&fp, &n);
#endif
/* Read in info from the file, setting up Fsa and so on... */
switch (read_file_info(fp)) {
case FORMAT_ERROR:
ERROR(FORMAT);
case NOT_A_GEN:
ERROR(GEN_ERR);
}
fclose(fp); /* No more reading required */
tuples = find_n_criticals(n);
/* remove_inverse_criticals(&tuples); We are ignoring inverse tuples */
/* Calc boundaries and store in an array */
boundary = NEW(BOUNDARY *, tuples->num);
for (i = 0; i < tuples->num; i++) {
boundary[i] = calc_bound(cube =
create_n_cube(tuples->info[i]->word,
tuples->info[i]->vert, n), TRIVIAL | RETAIN_INV_TUPLES);
/* We are ignoring inverse tuples */
delete_cube(cube);
}
lower_dim_tuples = find_n_criticals(n-1);
/* remove_inverse_criticals(&lower_dim_tuples); Ignoring inverse tuples */
num_rows = tuples->num;
/* Create the matrix */
matrix = make_matrix_n(boundary, lower_dim_tuples, &num_rows);
num_cols = lower_dim_tuples->num;
/* It is often useful to have rows and columns the other way */
/* Get transpose, and swap rows and cols */
tmatrix = transpose(matrix, num_cols, num_rows);
temp = num_rows;
num_rows = num_cols;
num_cols = temp;
/* Display....for now */
printf("\nMatrix: rows = %d, cols = %d\n\n", num_rows, num_cols);
show_matrix(stdout, tmatrix, num_cols, num_rows, 20);
/*printf("\nMatrix after Gaussian Elimination...\n");
gaussian_elim(matrix, num_cols, num_rows);
show_matrix(stdout, matrix, num_cols, num_rows);
rank_criticals_n = count_non_zero_rows(matrix, num_cols, num_rows);*/
/* Clean up */
for (i=0; i < tuples->num - Num_gens; i++)
delete_boundary(boundary[i]);
free(boundary);
delete_criticals(tuples);
delete_criticals(lower_dim_tuples);
delete_matrix(matrix, num_cols);
delete_matrix(tmatrix, num_rows);
return 0;
}
//expects c to be initialized
void strassen_mult(matrix a, matrix b, matrix c){
matrix quar[12];
matrix m[7];
matrix temp1, temp2;
int size = a.size/2;
int i,j;
// if(size==0){
// c.rows[0][0] = a.rows[0][0] * b.rows[0][0];
// return;
// }
if (a.size <= BREAK) {
int i, j, k;
for (i = 0; i < (a.size); i++) {
for (k = 0; k < (a.size); k++) {
for (j = 0; j < (a.size); j++) {
c.rows[i][j] += a.rows[i][k] * b.rows[k][j];
}
}
}
}
quar[0]=get00(a); quar[1]=get01(a);
quar[2]=get10(a); quar[3]=get11(a);
quar[4]=get00(b); quar[5]=get01(b);
quar[6]=get10(b); quar[7]=get11(b);
quar[8]=get00(c); quar[9]=get01(c);
quar[10]=get10(c); quar[11]=get11(c);
for(i=0;i<7;i++){
m[i] = new_matrix(size);
}
if (a.size <= BREAK)
goto group;
temp1 = new_matrix(size);
temp2 = new_matrix(size);
plus(quar[0], quar[3], temp1);
plus(quar[4], quar[7], temp2);
strassen_mult(temp1,temp2,m[0]);
plus(quar[2], quar[3], temp1);
strassen_mult(temp1, quar[4], m[1]);
minus(quar[5], quar[7], temp2);
strassen_mult(quar[0], temp2, m[2]);
minus(quar[6], quar[4], temp2);
strassen_mult(quar[3], temp2, m[3]);
plus(quar[0], quar[1], temp1);
strassen_mult(temp1, quar[7], m[4]);
minus(quar[2], quar[0], temp1);
plus(quar[4], quar[5], temp2);
strassen_mult(temp1, temp2, m[5]);
minus(quar[1], quar[3], temp1);
plus(quar[6], quar[7], temp2);
strassen_mult(temp1, temp2, m[6]);
delete_matrix(temp1);
delete_matrix(temp2);
group:
for(i=0;i<size;i++){
for(j=0;j<size;j++){
quar[8].rows[i][j] = m[0].rows[i][j] + m[3].rows[i][j] - m[4].rows[i][j] + m[6].rows[i][j];
quar[9].rows[i][j] = m[2].rows[i][j] + m[4].rows[i][j];
quar[10].rows[i][j] = m[1].rows[i][j] + m[3].rows[i][j];
quar[11].rows[i][j] = m[0].rows[i][j] - m[1].rows[i][j] + m[2].rows[i][j] + m[5].rows[i][j];
}
}
for(i=0;i<12;i++){
delete_matrix(quar[i]);
}
for(i=0;i<7;i++){
delete_matrix(m[i]);
}
}
/*--------------------------------------------*/
bool NOMAD::TGP_Model::compute
(std::vector<NOMAD::Eval_Point *> &XX_pts , // IN/OUT
bool compute_Ds2x , // IN
bool compute_improv , // IN
bool pred_outside_bnds) // IN
{
_model_computed = false;
if (!_error_str.empty())
return false;
int i , j , index_obj = -1 , n_XX0 = XX_pts.size() , m = _bbot.size();
// check bbot: there must be exactly one objective:
for (i = 0 ; i < m ; ++i)
{
if (_bbot[i] == NOMAD::OBJ)
{
if (index_obj < 0)
index_obj = i;
else
{
_error_str = "more than one objective";
return false;
}
}
}
if (index_obj < 0)
{
_error_str = "no objective";
return false;
}
// check n_XX0:
if (n_XX0 == 0)
{
_error_str = "no user-provided prediction point";
return false;
}
// reset XX_pts outputs:
for (i = 0 ; i < n_XX0 ; ++i)
{
for (j = 0 ; j < m ; ++j)
XX_pts[i]->set_bb_output(j , NOMAD::Double());
XX_pts[i]->set_eval_status(NOMAD::EVAL_FAIL);
}
// create the XX matrix (prediction points):
std::vector<NOMAD::Eval_Point *> XX_filtered_pts;
NOMAD::Eval_Point *cur2;
// the list of points has to be filtered:
NOMAD::Double tmp;
bool chk;
for (i = 0 ; i < n_XX0 ; ++i)
{
if (XX_pts[i]->size() == _n0)
{
cur2 = XX_pts[i];
chk = true;
for (j = 0 ; j < _n0 ; ++j)
{
tmp = (*cur2)[j];
if (!pred_outside_bnds && (tmp < _lb[j] || tmp > _ub[j]))
{
chk = false;
break;
}
}
if (chk)
XX_filtered_pts.push_back(cur2);
}
}
if (_XX)
{
for (i = 0 ; i < _n_XX ; ++i)
delete [] _XX[i];
delete [] _XX;
}
_n_XX = XX_filtered_pts.size();
if (_n_XX == 0)
{
_error_str = "no prediction point after filtering";
return false;
}
_XX = new double * [_n_XX];
for (i = 0 ; i < _n_XX ; ++i)
{
_XX[i] = new double[_n];
for (j = 0 ; j < _n ; ++j)
_XX[i][j] = (*XX_filtered_pts[i])[_fv_index[j]].value();
}
// Xsplit: X+XX: size = nsplit x n:
int nsplit = _p + _n_XX;
double **Xsplit = new double * [nsplit];
for (i = 0 ; i < _p ; ++i)
{
Xsplit[i] = new double [_n];
for (j = 0 ; j < _n ; ++j)
Xsplit[i][j] = _X[i][j];
}
for (i = _p ; i < nsplit ; ++i)
{
Xsplit[i] = new double [_n];
for (j = 0 ; j < _n ; ++j)
Xsplit[i][j] = _XX[i-_p][j];
}
// get the rectangle:
if (_tgp_rect)
delete_matrix(_tgp_rect);
_tgp_rect = get_data_rect(Xsplit , nsplit , _n);
// TGP parameters:
Params tgp_params(_n);
double *dparams = NOMAD::TGP_Model::get_TGP_dparams(_n);
tgp_params.read_double(dparams);
delete [] dparams;
int BTE[3];
if (!get_BTE(BTE))
{
for (i = 0 ; i < nsplit ; ++i)
delete [] Xsplit[i];
delete [] Xsplit;
return false;
}
// display BTE:
#ifdef TGP_DEBUG
_out << std::endl
<< "BTE={" << BTE[0] << ", " << BTE[1] << ", " << BTE[2] << "}"
<< std::endl;
#endif
// compute the individual TGP models (one for each output):
double *ZZ = new double [_n_XX];
// Ds2x, expected reduction in predictive variance:
if (_Ds2x == NULL)
{
_Ds2x = new double * [m];
for (i = 0 ; i < m ; ++i)
_Ds2x[i] = NULL;
}
else
{
for (i = 0 ; i < m ; ++i)
if (_Ds2x[i])
{
delete [] _Ds2x[i];
_Ds2x[i] = NULL;
}
}
// improv, expected improvement of the objective (ranks):
if (_improv)
{
delete [] _improv;
_improv = NULL;
}
if (compute_improv)
_improv = new int [_n_XX];
for (i = 0 ; i < m ; ++i)
{
if (_tgp_models[i])
{
_Ds2x[i] = (compute_Ds2x) ? new double [_n_XX] : NULL;
_tgp_models[i]->compute(_X ,
_XX ,
Xsplit ,
_n ,
_n_XX ,
nsplit ,
&tgp_params ,
_tgp_rect ,
BTE ,
_tgp_linburn ,
_tgp_verb ,
ZZ ,
_Ds2x[i] ,
(i==index_obj) ? _improv : NULL);
// set XX_pts outputs #i:
for (j = 0 ; j < _n_XX ; ++j)
{
XX_filtered_pts[j]->set_bb_output(i , ZZ[j]);
XX_filtered_pts[j]->set_eval_status(NOMAD::EVAL_OK);
}
// check if TGP has been interrupted:
if (NOMAD::TGP_Output_Model::get_force_quit())
{
_error_str = "TGP has been interrupted with ctrl-c";
break;
}
}
}
// clear memory:
for (i = 0 ; i < nsplit ; ++i)
delete [] Xsplit[i];
delete [] Xsplit;
delete [] ZZ;
_model_computed = _error_str.empty();
return _model_computed;
}
void strassen_8thread_mult(matrix a, matrix b, matrix c){
matrix quar[12];
matrix m[7];
struct work_struct *jobs[7];
int size = a.size/2;
int i, j;
if(size==0){
c.rows[0][0] = a.rows[0][0] * b.rows[0][0];
return;
}
/*
if (a.size <= BREAK) {
int i, j, k;
for (i = 0; i < (a.size); i++) {
for (k = 0; k < (a.size); k++) {
for (j = 0; j < (a.size); j++) {
c.rows[i][j] += a.rows[i][k] * b.rows[k][j];
}
}
}
return;
}
*/
job_init();
quar[0]=get00(a); quar[1]=get01(a);
quar[2]=get10(a); quar[3]=get11(a);
quar[4]=get00(b); quar[5]=get01(b);
quar[6]=get10(b); quar[7]=get11(b);
quar[8]=get00(c); quar[9]=get01(c);
quar[10]=get10(c); quar[11]=get11(c);
for(i=0;i<7;i++){
m[i] = new_matrix(size);
}
for (i = 0; i < 7; i++) {
jobs[i] = malloc(sizeof(struct work_struct));
if (jobs[i] == NULL) {
perror(NULL);
exit(1);
}
}
jobs[0]->a_1 = quar[0];
jobs[0]->a_2 = quar[3];
jobs[0]->b_1 = quar[4];
jobs[0]->b_2 = quar[7];
jobs[0]->c = m[0];
jobs[0]->tid = 0;
job_create(thread_main, jobs[0], 0);
jobs[1]->a_1 = quar[2];
jobs[1]->a_2 = quar[3];
jobs[1]->b_1 = quar[4];
jobs[1]->c = m[1];
jobs[1]->tid = 1;
job_create(thread_main, jobs[1], 0);
jobs[2]->a_1 = quar[0];
jobs[2]->b_1 = quar[5];
jobs[2]->b_2 = quar[7];
jobs[2]->c = m[2];
jobs[2]->tid = 2;
job_create(thread_main, jobs[2], 0);
jobs[3]->a_1 = quar[3];
jobs[3]->b_1 = quar[6];
jobs[3]->b_2 = quar[4];
jobs[3]->c = m[3];
jobs[3]->tid = 3;
job_create(thread_main, jobs[3], 0);
jobs[4]->a_1 = quar[0];
jobs[4]->a_2 = quar[1];
jobs[4]->b_1 = quar[7];
jobs[4]->c = m[4];
jobs[4]->tid = 4;
job_create(thread_main, jobs[4], 0);
jobs[5]->a_1 = quar[2];
jobs[5]->a_2 = quar[0];
jobs[5]->b_1 = quar[4];
jobs[5]->b_2 = quar[5];
jobs[5]->c = m[5];
jobs[5]->tid = 5;
job_create(thread_main, jobs[5], 0);
jobs[6]->a_1 = quar[1];
jobs[6]->a_2 = quar[3];
jobs[6]->b_1 = quar[6];
jobs[6]->b_2 = quar[7];
jobs[6]->c = m[6];
jobs[6]->tid = 6;
job_create(thread_main, jobs[6], 0);
for(i=0;i<7;i++){
job_join(jobs[i]);
}
for(i=0;i<size;i++){
for(j=0;j<size;j++){
quar[8].rows[i][j] = m[0].rows[i][j] + m[3].rows[i][j] - m[4].rows[i][j] + m[6].rows[i][j];
quar[9].rows[i][j] = m[2].rows[i][j] + m[4].rows[i][j];
quar[10].rows[i][j] = m[1].rows[i][j] + m[3].rows[i][j];
quar[11].rows[i][j] = m[0].rows[i][j] - m[1].rows[i][j] + m[2].rows[i][j] + m[5].rows[i][j];
}
}
for(i=0;i<12;i++){
delete_matrix(quar[i]);
}
for(i=0;i<7;i++){
delete_matrix(m[i]);
}
}
