// ******************** FlopCpp **********************************************
// File: MP_variable.cpp
// $Id$
// Author: Tim Helge Hultberg (thh@mat.ua.pt)
// Copyright (C) 2003 Tim Helge Hultberg
// All Rights Reserved.
//****************************************************************************

#include <iostream>
#include <sstream>
using std::cout;
using std::endl;

#include <OsiSolverInterface.hpp>
#include "MP_variable.hpp"
#include "MP_domain.hpp" 
#include "MP_constant.hpp" 
#include "MP_model.hpp"
using namespace flopc;

VariableRef::VariableRef(MP_variable* v, 
			 const MP_index_exp& i1,
			 const MP_index_exp& i2,
			 const MP_index_exp& i3,
			 const MP_index_exp& i4,
			 const MP_index_exp& i5) :
    V(v),I1(i1),I2(i2),I3(i3),I4(i4),I5(i5) { 
    offset = v->offset; 
}
    std::string VariableRef::toString()const
    {
        std::stringstream ss;
        const MP_index_base *pExpIdx = MP_index_exp::getEmpty().operator->();

        ss<<V->toString()<<'[';
        if(I1.operator->() != pExpIdx)
            ss<<I1->getName();
        if(I2.operator->() != pExpIdx)
            ss<<','<<I2->getName();
        if(I3.operator->() != pExpIdx)
            ss<<','<<I3->getName();
        if(I4.operator->() != pExpIdx)
            ss<<','<<I4->getName();
        if(I5.operator->() != pExpIdx)
            ss<<','<<I5->getName();
        ss<<"]";
        return ss.str();
    }

double VariableRef::level() const {
    return  V->M->solution[V->offset +
			   V->f(V->S1->evaluate(),
				V->S2->evaluate(),
				V->S3->evaluate(),
				V->S4->evaluate(),
				V->S5->evaluate())];
}

int VariableRef::getColumn() const { 
    int i1 = V->S1->check(I1->evaluate());
    int i2 = V->S2->check(I2->evaluate());
    int i3 = V->S3->check(I3->evaluate());
    int i4 = V->S4->check(I4->evaluate());
    int i5 = V->S5->check(I5->evaluate());
    
    if (i1==outOfBound || i2==outOfBound || i3==outOfBound ||
	i4==outOfBound || i5==outOfBound) {
	return outOfBound;
    } else {
	return V->offset +  V->f(i1,i2,i3,i4,i5);
    }
}

void VariableRef::generate(const MP_domain& domain,
			   vector<Constant > multiplicators,
			   GenerateFunctor& f,
			   double m)  const {
    f.setMultiplicator(multiplicators,m);
    f.setTerminalExpression(this);
    domain.Forall(&f);
}
 
MP_variable::MP_variable(const MP_set_base &s1, 
			 const MP_set_base &s2, 
			 const MP_set_base &s3,
			 const MP_set_base &s4, 
			 const MP_set_base &s5) :
    RowMajor(s1.size(),s2.size(),s3.size(),s4.size(),s5.size()),
    upperLimit(MP_data(s1,s2,s3,s4,s5)),
    lowerLimit(MP_data(s1,s2,s3,s4,s5)),
    S1(&s1),S2(&s2),S3(&s3),S4(&s4),S5(&s5),
    offset(-1)
{
    lowerLimit.initialize(0.0);
    upperLimit.initialize(MP_model::getDefaultModel().getInfinity());
    type = continuous;
}    

double MP_variable::level(int i1, int i2, int i3, int i4, int i5) {
    return M->solution[offset +  f(i1,i2,i3,i4,i5)];
}

void MP_variable::operator()() const {
    if (S1!=&MP_set::getEmpty()) cout << i1.evaluate() << " ";
    if (S2!=&MP_set::getEmpty()) cout << i2.evaluate() << " ";
    if (S3!=&MP_set::getEmpty()) cout << i3.evaluate() << " ";
    if (S4!=&MP_set::getEmpty()) cout << i4.evaluate() << " ";
    if (S5!=&MP_set::getEmpty()) cout << i5.evaluate() << " ";
    cout<<"  "<< M->solution[offset +
			     f(i1.evaluate(),
			       i2.evaluate(),
			       i3.evaluate(),
			       i4.evaluate(),
			       i5.evaluate())]<<endl;
}
std::string MP_variable::toString()const
{
    MP_variable *nonConstThis = const_cast<MP_variable *>(this);
    std::stringstream ss;
    if(getName().length()==0)
        ss<<"unnamed";
    else
        ss<<getName();
    /*
  if (offset >= 0) {
    ((*(nonConstThis->S1))(nonConstThis->i1)*(*(nonConstThis->S2))(nonConstThis->i2)*(*(nonConstThis->S3))(nonConstThis->i3)*(*(nonConstThis->S4))(nonConstThis->i4)*(*(nonConstThis->S5))(nonConstThis->i5)).Forall(this);
  } else {
    ss<<"No solution available!"<<endl;
  }
    */
  return ss.str();
}
void MP_variable::display(const std::string &s) {
  cout<<s<<endl;
  if (offset >= 0) {
    ((*S1)(i1)*(*S2)(i2)*(*S3)(i3)*(*S4)(i4)*(*S5)(i5)).Forall(this);
  } else {
    cout<<"No solution available!"<<endl;
  }
}