int main(int nargs, char *args[])
{
int n = 6; // Number of dimensions
// Common configuration
// See parameters.h for the available options
// If we initialize the struct with the DEFAUL_PARAMS,
// the we can optionally change only few of them
bopt_params par = initialize_parameters_to_default();
par.kernel.hp_mean[0] = KERNEL_THETA;
par.kernel.hp_std[0] = 1.0;
par.kernel.n_hp = 1;
par.mean.coef_mean[0] = 0.0;
par.mean.coef_std[0] = MEAN_SIGMA;
par.mean.n_coef = 1;
par.noise = DEFAULT_NOISE;
par.surr_name = "sStudentTProcessJef";
par.n_iterations = 20; // Number of iterations
par.n_init_samples = 20;
/*******************************************/
size_t nPoints = 1000;
randEngine mtRandom;
matrixd xPoints(nPoints,n);
vecOfvec xP;
//Thanks to the quirks of Visual Studio, the following expression is invalid,
//so we have to replace it by a literal.
//WARNING: Make sure to update the size of the array if the number of points
//or dimensions change.
#ifdef _MSC_VER
double xPointsArray[6000];
#else
const size_t nPinArr = n*nPoints;
double xPointsArray[nPinArr];
#endif
bayesopt::utils::lhs(xPoints,mtRandom);
for(size_t i = 0; i<nPoints; ++i)
{
vectord point = row(xPoints,i);
xP.push_back(point);
for(size_t j=0; j<n; ++j)
{
xPointsArray[i*n+j] = point(j);
}
}
// Run C++ interface
std::cout << "Running C++ interface" << std::endl;
ExampleDisc opt(xP,par);
vectord result(n);
opt.optimize(result);
// Run C interface
std::cout << "Running C interface" << std::endl;
double x[128], fmin[128];
bayes_optimization_disc(n, &testFunction, NULL, xPointsArray, nPoints,
x, fmin, par);
// Find the optimal value
size_t min = 0;
double minvalue = opt.evaluateSample(row(xPoints,min));
for(size_t i = 1; i<nPoints; ++i)
{
vectord point = row(xPoints,i);
if (opt.evaluateSample(point) < minvalue)
{
min = i;
minvalue = opt.evaluateSample(row(xPoints,min));
std::cout << i << "," << minvalue << std::endl;
}
}
std::cout << "Final result C++: " << result << std::endl;
std::cout << "Final result C: (";
for (int i = 0; i < n; i++ )
std::cout << x[i] << ", ";
std::cout << ")" << std::endl;
std::cout << "Optimal: " << row(xPoints,min) << std::endl;
}
void Basis_HCURL_QUAD_In_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues,
const ArrayScalar & inputPoints,
const EOperator operatorType) const {
// Verify arguments
#ifdef HAVE_INTREPID_DEBUG
Intrepid2::getValues_HCURL_Args<Scalar, ArrayScalar>(outputValues,
inputPoints,
operatorType,
this -> getBaseCellTopology(),
this -> getCardinality() );
#endif
// Number of evaluation points = dim 0 of inputPoints
int dim0 = inputPoints.dimension(0);
// separate out points
FieldContainer<Scalar> xPoints(dim0,1);
FieldContainer<Scalar> yPoints(dim0,1);
for (int i=0;i<dim0;i++) {
xPoints(i,0) = inputPoints(i,0);
yPoints(i,0) = inputPoints(i,1);
}
switch (operatorType) {
case OPERATOR_VALUE:
{
FieldContainer<Scalar> closedBasisValsXPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> closedBasisValsYPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
closedBasis_.getValues( closedBasisValsXPts , xPoints , OPERATOR_VALUE );
closedBasis_.getValues( closedBasisValsYPts , yPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
int bfcur = 0;
// x component bfs are (open(x) closed(y),0)
for (int j=0;j<closedBasis_.getCardinality();j++)
{
for (int i=0;i<openBasis_.getCardinality();i++)
{
for (int l=0;l<dim0;l++)
{
outputValues(bfcur,l,0) = closedBasisValsYPts(j,l) * openBasisValsXPts(i,l);
outputValues(bfcur,l,1) = 0.0;
}
bfcur++;
}
}
// y component bfs are (0,closed(x) open(y))
for (int j=0;j<openBasis_.getCardinality();j++)
{
for (int i=0;i<closedBasis_.getCardinality();i++)
{
for (int l=0;l<dim0;l++)
{
outputValues(bfcur,l,0) = 0.0;
outputValues(bfcur,l,1) = openBasisValsYPts(j,l) * closedBasisValsXPts(i,l);
}
bfcur++;
}
}
}
break;
case OPERATOR_CURL:
{
FieldContainer<Scalar> closedBasisDerivsXPts( closedBasis_.getCardinality() , dim0 , 1 );
FieldContainer<Scalar> closedBasisDerivsYPts( closedBasis_.getCardinality() , dim0 , 1 );
FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
closedBasis_.getValues( closedBasisDerivsXPts , xPoints , OPERATOR_D1 );
closedBasis_.getValues( closedBasisDerivsYPts , yPoints , OPERATOR_D1 );
openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
int bfcur = 0;
// x component basis functions first
for (int j=0;j<closedBasis_.getCardinality();j++)
{
for (int i=0;i<openBasis_.getCardinality();i++)
{
for (int l=0;l<dim0;l++) {
outputValues(bfcur,l) = -closedBasisDerivsYPts(j,l,0) * openBasisValsXPts(i,l);
}
bfcur++;
}
}
// now y component basis functions
for (int j=0;j<openBasis_.getCardinality();j++)
{
for (int i=0;i<closedBasis_.getCardinality();i++)
{
for (int l=0;l<dim0;l++)
{
outputValues(bfcur,l) = closedBasisDerivsXPts(i,l,0) * openBasisValsYPts(j,l);
}
bfcur++;
}
}
}
break;
case OPERATOR_DIV:
TEUCHOS_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_DIV), std::invalid_argument,
">>> ERROR (Basis_HCURL_QUAD_In_FEM): DIV is invalid operator for HCURL Basis Functions");
break;
case OPERATOR_GRAD:
TEUCHOS_TEST_FOR_EXCEPTION( (operatorType == OPERATOR_GRAD), std::invalid_argument,
">>> ERROR (Basis_HCURL_QUAD_In_FEM): GRAD is invalid operator for HCURL Basis Functions");
break;
case OPERATOR_D1:
case OPERATOR_D2:
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10:
TEUCHOS_TEST_FOR_EXCEPTION( ( (operatorType == OPERATOR_D1) ||
(operatorType == OPERATOR_D2) ||
(operatorType == OPERATOR_D3) ||
(operatorType == OPERATOR_D4) ||
(operatorType == OPERATOR_D5) ||
(operatorType == OPERATOR_D6) ||
(operatorType == OPERATOR_D7) ||
(operatorType == OPERATOR_D8) ||
(operatorType == OPERATOR_D9) ||
(operatorType == OPERATOR_D10) ),
std::invalid_argument,
">>> ERROR (Basis_HCURL_QUAD_In_FEM): Invalid operator type");
break;
default:
TEUCHOS_TEST_FOR_EXCEPTION( ( (operatorType != OPERATOR_VALUE) &&
(operatorType != OPERATOR_GRAD) &&
(operatorType != OPERATOR_CURL) &&
(operatorType != OPERATOR_CURL) &&
(operatorType != OPERATOR_D1) &&
(operatorType != OPERATOR_D2) &&
(operatorType != OPERATOR_D3) &&
(operatorType != OPERATOR_D4) &&
(operatorType != OPERATOR_D5) &&
(operatorType != OPERATOR_D6) &&
(operatorType != OPERATOR_D7) &&
(operatorType != OPERATOR_D8) &&
(operatorType != OPERATOR_D9) &&
(operatorType != OPERATOR_D10) ),
std::invalid_argument,
">>> ERROR (Basis_HCURL_QUAD_In_FEM): Invalid operator type");
}
}
void Basis_HCURL_HEX_In_FEM<Scalar, ArrayScalar>::getValues(ArrayScalar & outputValues,
const ArrayScalar & inputPoints,
const EOperator operatorType) const {
// Verify arguments
#ifdef HAVE_INTREPID_DEBUG
Intrepid::getValues_HCURL_Args<Scalar, ArrayScalar>(outputValues,
inputPoints,
operatorType,
this -> getBaseCellTopology(),
this -> getCardinality() );
#endif
// Number of evaluation points = dim 0 of inputPoints
int dim0 = inputPoints.dimension(0);
// separate out points
FieldContainer<Scalar> xPoints(dim0,1);
FieldContainer<Scalar> yPoints(dim0,1);
FieldContainer<Scalar> zPoints(dim0,1);
for (int i=0;i<dim0;i++) {
xPoints(i,0) = inputPoints(i,0);
yPoints(i,0) = inputPoints(i,1);
zPoints(i,0) = inputPoints(i,2);
}
switch (operatorType) {
case OPERATOR_VALUE:
{
FieldContainer<Scalar> closedBasisValsXPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> closedBasisValsYPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> closedBasisValsZPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsZPts( openBasis_.getCardinality() , dim0 );
closedBasis_.getValues( closedBasisValsXPts , xPoints , OPERATOR_VALUE );
closedBasis_.getValues( closedBasisValsYPts , yPoints , OPERATOR_VALUE );
closedBasis_.getValues( closedBasisValsZPts , zPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsZPts , zPoints , OPERATOR_VALUE );
// first we get the "horizontal basis functions that are tangent to the x-varying edges
int bfcur = 0;
for (int k=0;k<closedBasis_.getCardinality();k++) {
for (int j=0;j<closedBasis_.getCardinality();j++) {
for (int i=0;i<openBasis_.getCardinality();i++) {
for (int l=0;l<dim0;l++) {
outputValues(bfcur,l,0) = openBasisValsXPts(i,l) * closedBasisValsYPts(j,l) * closedBasisValsZPts(k,l);
outputValues(bfcur,l,1) = 0.0;
outputValues(bfcur,l,2) = 0.0;
}
bfcur++;
}
}
}
// second we get the basis functions in the direction of the y-varying edges
for (int k=0;k<closedBasis_.getCardinality();k++) {
for (int j=0;j<openBasis_.getCardinality();j++) {
for (int i=0;i<closedBasis_.getCardinality();i++) {
for (int l=0;l<dim0;l++) {
outputValues(bfcur,l,0) = 0.0;
outputValues(bfcur,l,1) = closedBasisValsXPts(i,l) * openBasisValsYPts(j,l) * closedBasisValsZPts(k,l);
outputValues(bfcur,l,2) = 0.0;
}
bfcur++;
}
}
}
// third we get the basis functions in the direction of the y-varying edges
for (int k=0;k<openBasis_.getCardinality();k++) {
for (int j=0;j<closedBasis_.getCardinality();j++) {
for (int i=0;i<closedBasis_.getCardinality();i++) {
for (int l=0;l<dim0;l++) {
outputValues(bfcur,l,0) = 0.0;
outputValues(bfcur,l,1) = 0.0;
outputValues(bfcur,l,2) = closedBasisValsXPts(i,l) * closedBasisValsYPts(j,l) * openBasisValsZPts(k,l);
}
bfcur++;
}
}
}
}
break;
case OPERATOR_CURL:
{
FieldContainer<Scalar> closedBasisValsXPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> closedBasisValsYPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> closedBasisValsZPts( closedBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> closedBasisDerivsXPts( closedBasis_.getCardinality() , dim0 , 1 );
FieldContainer<Scalar> closedBasisDerivsYPts( closedBasis_.getCardinality() , dim0 , 1 );
FieldContainer<Scalar> closedBasisDerivsZPts( closedBasis_.getCardinality() , dim0 , 1 );
FieldContainer<Scalar> openBasisValsXPts( openBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsYPts( openBasis_.getCardinality() , dim0 );
FieldContainer<Scalar> openBasisValsZPts( openBasis_.getCardinality() , dim0 );
closedBasis_.getValues( closedBasisValsXPts , xPoints , OPERATOR_VALUE );
closedBasis_.getValues( closedBasisValsYPts , yPoints , OPERATOR_VALUE );
closedBasis_.getValues( closedBasisValsZPts , zPoints , OPERATOR_VALUE );
closedBasis_.getValues( closedBasisDerivsXPts , xPoints , OPERATOR_D1 );
closedBasis_.getValues( closedBasisDerivsYPts , yPoints , OPERATOR_D1 );
closedBasis_.getValues( closedBasisDerivsZPts , zPoints , OPERATOR_D1 );
openBasis_.getValues( openBasisValsXPts , xPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsYPts , yPoints , OPERATOR_VALUE );
openBasis_.getValues( openBasisValsZPts , zPoints , OPERATOR_VALUE );
int bfcur = 0;
// first we get the basis functions that are tangent to the x-varying edges
for (int k=0;k<closedBasis_.getCardinality();k++) {
for (int j=0;j<closedBasis_.getCardinality();j++) {
for (int i=0;i<openBasis_.getCardinality();i++) {
for (int l=0;l<dim0;l++) {
outputValues(bfcur,l,0) = 0.0;
outputValues(bfcur,l,1) = -openBasisValsXPts(i,l) * closedBasisValsYPts(j,l) * closedBasisDerivsZPts(k,l,0);
outputValues(bfcur,l,2) = openBasisValsXPts(i,l) * closedBasisDerivsYPts(j,l,0) * closedBasisValsZPts(k,l);
}
bfcur++;
}
}
}
// second we get the basis functions in the direction of the y-varying edges
for (int k=0;k<closedBasis_.getCardinality();k++) {
for (int j=0;j<openBasis_.getCardinality();j++) {
for (int i=0;i<closedBasis_.getCardinality();i++) {
for (int l=0;l<dim0;l++) {
outputValues(bfcur,l,0) = -closedBasisValsXPts(i,l) * openBasisValsYPts(j,l) * closedBasisDerivsZPts(k,l,0);
outputValues(bfcur,l,1) = 0.0;
outputValues(bfcur,l,2) = closedBasisDerivsXPts(i,l,0) * openBasisValsYPts(j,l) * closedBasisValsZPts(k,l);
}
bfcur++;
}
}
}
// third we get the basis functions in the direction of the y-varying edges
for (int k=0;k<openBasis_.getCardinality();k++) {
for (int j=0;j<closedBasis_.getCardinality();j++) {
for (int i=0;i<closedBasis_.getCardinality();i++) {
for (int l=0;l<dim0;l++) {
outputValues(bfcur,l,0) = closedBasisValsXPts(i,l) * closedBasisDerivsYPts(j,l,0) * openBasisValsZPts(k,l);
outputValues(bfcur,l,1) = -closedBasisDerivsXPts(i,l,0) * closedBasisValsYPts(j,l) * openBasisValsZPts(k,l);
outputValues(bfcur,l,2) = 0.0;
}
bfcur++;
}
}
}
}
break;
case OPERATOR_DIV:
TEST_FOR_EXCEPTION( (operatorType == OPERATOR_DIV), std::invalid_argument,
">>> ERROR (Basis_HCURL_HEX_In_FEM): DIV is invalid operator for HCURL Basis Functions");
break;
case OPERATOR_GRAD:
TEST_FOR_EXCEPTION( (operatorType == OPERATOR_GRAD), std::invalid_argument,
">>> ERROR (Basis_HCURL_HEX_In_FEM): GRAD is invalid operator for HCURL Basis Functions");
break;
case OPERATOR_D1:
case OPERATOR_D2:
case OPERATOR_D3:
case OPERATOR_D4:
case OPERATOR_D5:
case OPERATOR_D6:
case OPERATOR_D7:
case OPERATOR_D8:
case OPERATOR_D9:
case OPERATOR_D10:
TEST_FOR_EXCEPTION( ( (operatorType == OPERATOR_D1) ||
(operatorType == OPERATOR_D2) ||
(operatorType == OPERATOR_D3) ||
(operatorType == OPERATOR_D4) ||
(operatorType == OPERATOR_D5) ||
(operatorType == OPERATOR_D6) ||
(operatorType == OPERATOR_D7) ||
(operatorType == OPERATOR_D8) ||
(operatorType == OPERATOR_D9) ||
(operatorType == OPERATOR_D10) ),
std::invalid_argument,
">>> ERROR (Basis_HCURL_HEX_In_FEM): Invalid operator type");
break;
default:
TEST_FOR_EXCEPTION( ( (operatorType != OPERATOR_VALUE) &&
(operatorType != OPERATOR_GRAD) &&
(operatorType != OPERATOR_CURL) &&
(operatorType != OPERATOR_CURL) &&
(operatorType != OPERATOR_D1) &&
(operatorType != OPERATOR_D2) &&
(operatorType != OPERATOR_D3) &&
(operatorType != OPERATOR_D4) &&
(operatorType != OPERATOR_D5) &&
(operatorType != OPERATOR_D6) &&
(operatorType != OPERATOR_D7) &&
(operatorType != OPERATOR_D8) &&
(operatorType != OPERATOR_D9) &&
(operatorType != OPERATOR_D10) ),
std::invalid_argument,
">>> ERROR (Basis_HCURL_HEX_In_FEM): Invalid operator type");
}
}