crevice_1.cc

/* 
 * File:   crevice.cc
 * 
 * Copyright 2012 Heinrich Schuchardt <xypron.glpk@gmx.de>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <cstdlib>
#include <iostream>
#include "TermAbs.h"
#include "TermConstant.h"
#include "TermVariable.h"
#include "TermSum.h"
#include "TermProduct.h"
#include "Problem.h"
#include <string>
#include <sstream>
#include <time.h>
using namespace std;

const int n = 2;
const int w = 7;

string var(string name, int index1, int index2, int index3) {
    ostringstream os;
    os << name << "["
            << index1 << ","
            << index2 << ","
            << index3 << "]";
    return os.str();
}

int defineProblem(Problem *p, const int n, const int w) {
    srand(time(NULL));
    try {
        TermVariable *x, *y, *z;
        Term *obj, *t1, *t2, *t3, *t4, *t5, *t6;

        obj = TermConstant::create(p, 0.);

        for (int i = 0; i < n; i++) {
            for (int k = 0; k < n; k++) {
                for (int g = 0; g < n; g++) {
                    for (int h = 0; h < n; h++) {
                        for (int r = 0; r < n; r++) {
                            for (int s = 0; s < n; s++) {
                                t6 = TermConstant::create(p, 0.);
                                for (int t = 0; t < w; t++) {
                                    x = TermVariable::create(p, var("x", g, h, t));
                                    x->setLowerBound(-1);
                                    x->setUpperBound(1);
                                    y = TermVariable::create(p, var("y", r, s, t));
                                    y->setLowerBound(-1);
                                    y->setUpperBound(1);
                                    z = TermVariable::create(p, var("z", i, k, t));
                                    z->setLowerBound(-1);
                                    z->setUpperBound(1);
                                    t1 = TermProduct::create(p, z, x);
                                    t2 = TermProduct::create(p, t1, y);
                                    t6 = TermSum::create(p, t6, t2);
                                }
                                if (i == g && h == r && s == k) {
                                    t3 = TermConstant::create(p, -1);
                                } else {
                                    t3 = TermConstant::create(p, 0);
                                }
                                t4 = TermSum::create(p, t3, t6);
                                t5 = TermAbs::create(p, t4);
                                obj = TermSum::create(p, obj, t5);

                            }
                        }
                    }
                }
            }
        }
        p->setObjectiveFunction(obj);

    } catch (ProblemMismatchException) {
        cout << "Problem mismatch" << endl;
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}

int initializeVariableValues(Problem *p, vector<double>* variableValues) {
    int numberofVariables;
    numberofVariables = p->numberOfVariables();
    for (int i = 0; i < numberofVariables; i++) {
        double value;
        value = 1. - 2. * (double) rand() / (double) RAND_MAX;
        variableValues->insert(variableValues->end(), value);
    }
}

int main() {
    int ret;
    Problem *p;
    vector<double>* variableValues;
    DoubleVector *hessian;

    srand(time(NULL));

    p = new Problem();

    ret = defineProblem(p, n, w);
    if (ret != EXIT_SUCCESS) {
        return ret;
    }
    cout << "Number of variables: " << p->numberOfVariables() << endl;
    cout << "Number of terms: " << p->numberOfTerms() << endl;


    variableValues = new vector<double>();
    initializeVariableValues(p, variableValues);

    cout << p->getObjectiveFunction()->evaluate(variableValues) << endl;

    if (p->hessian(variableValues, &hessian)) {
        cout << "Size of Hessian " << hessian->size() << endl;
        delete hessian;
    }

    cout << "Number of terms: " << p->numberOfTerms() << endl;


    delete(variableValues);
    delete p;

    return EXIT_SUCCESS;
}