Problem.cc

/* 
 * File:   Problem.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 "Problem.h"
#include "TermVariable.h"

Problem::Problem() {
    this->hessian_ = NULL;
    this->gradient_ = NULL;
    this->objectiveFunction_ = NULL;
    this->terms = new TermSet();
    this->variables_ = NULL;
    this->variablesSet_ = new VariableSet();
}

Problem::~Problem() {
    TermSet::iterator position;
    for (position = this->terms->begin();
            position != this->terms->end();
            position = this->terms->begin()) {
        Term *term = *position;
        this->terms->erase(position);
        delete term;
    }
    delete this->hessian_;
    delete this->gradient_;
    delete this->variables_;
    delete this->terms;
    delete this->variablesSet_;
}

Term* Problem::addTerm(Term* term) {
    Term* ret = term;
    if (0 == this->terms->count(term)) {
        // Term not found
        this->terms->insert(term);
        term->setTermIndex(this->terms->size());
    } else {
        // Find equivalent term
        ret = *this->terms->find(term);
        if (ret != term) {
            // Delete only if not identical term
            delete term;
        }
    }
    return ret;
}

TermVariable* Problem::addVariable(TermVariable* variable) {
    TermVariable* ret = static_cast<TermVariable *> (this->addTerm(variable));
    if (0 == this->variablesSet_->count(ret)) {
        // Variable not found
        this->variablesSet_->insert(ret);
        ret->setVariableIndex(this->variablesSet_->size() - 1);
    }
    return ret;
}

Term* Problem::setObjectiveFunction(Term* term) {
    Term* ret = this->addTerm(term);
    if (this->hessian_ != NULL) {
        delete this->hessian_;
        this->hessian_ = NULL;
    }
    if (this->gradient_ != NULL) {
        delete this->gradient_;
        this->gradient_ = NULL;
    }
    if (this->variables_ != NULL) {
        delete this->variables_;
        this->variables_ = NULL;
    }
    this->objectiveFunction_ = NULL;
    this->objectiveFunction_ = ret;
    return ret;
}

Term* Problem::getObjectiveFunction() {
    return this->objectiveFunction_;
}

TermPointerVector* Problem::getGradient() {
    if (this->gradient_ == NULL) {
        this->prepareGradient();
    }
    return this->gradient_;
}

TermPointerVector* Problem::getHessian() {
    if (this->hessian_ == NULL) {
        this->prepareHessian();
    }
    return this->hessian_;
}

TermVariablePointerVector* Problem::getVariables() {
    if (this->variables_ == NULL) {
        prepareVariables();
    }
    return this->variables_;
}

bool Problem::gradient(const DoubleVector* values,
        DoubleVector** gradient) {
    if (this->gradient_ == NULL) {
        prepareGradient();
    }
    int size = this->gradient_->size();
    *gradient = new DoubleVector(size);
    TermValueSet* termValues;
    termValues = new TermValueSet;
    for (int i = 0; i < size; i++) {
        (**gradient)[i] = (*gradient_)[i]->evaluate(values, termValues);
    }
    delete termValues;
    return true;
}

bool Problem::hessian(const DoubleVector* values,
        DoubleVector **hessian) {
    if (this->hessian_ == NULL) {
        prepareHessian();
    }
    int size = this->hessian_->size();
    *hessian = new DoubleVector(size);
    TermValueSet* termValues;
    termValues = new TermValueSet;
    for (int i = 0; i < size; i++) {
        (**hessian)[i] = (*hessian_)[i]->evaluate(values, termValues);
    }
    delete termValues;
    return true;
}

size_t Problem::numberOfTerms() {
    return this->terms->size();
}

size_t Problem::numberOfVariables() {
    return this->variablesSet_->size();
}

bool Problem::objective(const std::vector<double>* values,
        double* obj) {

    *obj = this->objectiveFunction_->evaluate(values);
    return false;
};

bool Problem::prepareGradient() {
    this->prepareVariables();
    if (this->gradient_ == NULL) {
        int size = this->variablesSet_->size();
        this->gradient_ = new TermPointerVector(size);
        for (int i = 0; i < size; i++) {
            (*this->gradient_)[i] =
                    this->objectiveFunction_->differentiate(
                    (*this->variables_)[i]);
        }
    }
    return true;
}

bool Problem::prepareHessian() {
    this->prepareGradient();
    if (this->hessian_ == NULL) {
        int size = this->variablesSet_->size();
        this->hessian_ = new TermPointerVector(size * size);
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                (*this->hessian_)[i + j * size] =
                        (*this->gradient_)[i]->differentiate(
                        (*this->variables_)[j]);
            }
        }
    }
    return true;
}

bool Problem::prepareVariables() {
    if (this->variables_ == NULL) {
        int size = this->variablesSet_->size();
        VariableSet::iterator variableRowPosition;
        this->variables_ = new TermVariablePointerVector(size);
        variableRowPosition = this->variablesSet_->begin();
        for (int i = 0; i < size; ++i) {
            (*this->variables_)[i] = *variableRowPosition;
            ++variableRowPosition;
        }
    }
    return true;
}