void Matrix::achievable_from(strvec &nodes, strvec from) const{
    int was = nodes.size();
    involved_with(nodes, from);
    if (nodes.size() == was)
        return;
    achievable_from(nodes, nodes);
}

void SplitLP::elModes(solvec& solutions, int num, strvec& fixcols){
    srand (unsigned(time(NULL)));
    double fixrate = 1/this->vmax;
    for (strvec::iterator it = fixcols.begin(); it != fixcols.end(); ++it){
        fix(*it, fixrate, true);
        fix(get_opp_name(*it), 0, true);
    }
    int kind = getKind() == MILP ? INT : CONT;
    void (MtxLP::*optimise)(stomap*, bool, strvec, bool, bool) = \
        (kind == INT) ? &MtxLP::optLenSol : &MtxLP::optSumSol;
    int i;
    for (i = 0; i < num; i++){
        stomap sol;
        (this->*optimise)(&sol, false, getColNames(), false, true);
        if (sol.empty())
            break;
        if (fixrate != 0) mul(&sol, vmax);
        solutions.push_back(sol);
        if (i < num - 1){
            sol.clear();
            MtxLP::getSolution(&sol, getColNames(kind), kind, false);
            if (kind == INT) cutSolution(&sol, true);
            else {
                for (strvec::iterator it = fixcols.begin();  it != fixcols.end(); ++it)
                     sol.erase(*it);
                int nblock = rand() % sol.size();
                stomap::iterator itblock = sol.begin();
                for (int i = 0; i < nblock; i++)itblock++;
                string sblock = itblock->first;
                block(sblock, true);
            }
        }
    }
    cleanTmpRows();//fixcols.size() * 2 + i - 1);
}

//Just outputs vecRef
void printVector(strvec& vecRef)
{
	for (int i = 0; i < vecRef.size(); i++)
	{
		std::cout << vecRef.at(i) << std::endl;
	}
}

void Matrix::del_cols(strvec &names){
    for (strvec::iterator it = names.begin(); it != names.end(); ++it){
        del(*it);
        std::remove(cols.begin(), cols.end(), *it);
    }
    cols.resize(cols.size() - names.size());
}

strvec MtxLP::get_int_names(strvec names){
    strvec rv(names.size());
    strvec::iterator it = names.begin(), it2 = rv.begin();
    while (it != names.end())
        *it2++ = get_int_name(*it++);
    return rv;
}

//Simple vector move function, pushes from from to to
void add(strvec& from, strvec& to)
{
	for (int i = 0; i < from.size(); i++)
	{
		to.push_back(from.at(i));
	}
}

strvec MtxLP::getUnblockedVars(strvec q, bool presolve){
    strvec rv;
    for (strvec::iterator it = q.begin(); it != q.end(); ++it){
        if (isUnBlocked(*it, presolve))
            rv.push_back(*it);
    }
    return rv;
}

strvec MtxLP::getBottleNecks(stomap* obj, strvec q, bool max, bool presolve){
    strvec rv;
    for (strvec::iterator it = q.begin(); it != q.end(); ++it){
        if (isBottleNeck(obj, *it, max, presolve))
            rv.push_back(*it);
    }
    return rv;
}

void MtxLP::getSupport(strvec& support, strvec queries, int kind) const{
    stomap sol;
    getSolution(&sol, queries, kind, false);
    support.resize(sol.size());
    strvec::iterator jt = support.begin();
    for (stomap::iterator it = sol.begin(); it != sol.end(); ++it)
        *jt++ = it->first;
}

void Matrix::involved_with(strvec& result, string name) const{
    stomap* sto = (*this)[name]->get_sto();
    for (stomap::iterator jt = sto->begin(); jt != sto->end(); ++jt){
        string name2 = jt->first;
        if (std::find(result.begin(), result.end(), name2) == result.end())
            result.push_back(name2);
    }
}

void MtxLP::optimiseLen(bool max, strvec q, bool presolve){
    if (q.empty())
        q = getColNames();
    setObjDir(max);
    setLenObjective(q, true);
    Solve(presolve);
    cleanTmpRows(q.size());
}

void MtxLP::externalise(strvec& names, bool on){
    double lb = on ? -UB : 0;
    double ub = on ? UB : 0;
    for (strvec::iterator it = names.begin(); it != names.end(); ++it){
        if (nrow(*it) != 0)
            setRowBnds(*it, lb, ub);
    }
}

void MtxLP::getRanges(rangemap* rm, strvec q, bool presolve){
    OBJSTAT_RANGE range;
    stomap targsto;
    for (strvec::iterator it = q.begin(); it != q.end(); ++it){
        string name = *it;
        getColRange(range, name, presolve);
        (*rm)[name] = range;
    }
}

void MtxLP::optimiseSum(bool max, strvec q, bool presolve){
    setObjDir(max);
    if (q.empty())
        q = getColNames();
    setObjective(q);
    Solve(presolve);
}

void MtxLP::setLenObjective(strvec cols, bool tmp){
    if (kind != MILP)
        throw runtime_error("trying to optimise length using a non-MILP solver!");
    emptyObjective();
    int contcoef = isMaximising() ? 1 : -1;
    int intcoef = -contcoef;
    for (strvec::iterator it = cols.begin(); it != cols.end(); ++it){
        string name = *it;
        string intname = get_int_name(name);
        stomap *sto = new stomap;
        (*sto)[name] = contcoef;
        (*sto)[intname] = intcoef * vmax;
        addConstraint(sto, 0, UB, tmp, name + INT_CONSTR_TAG);
        setObjCoef(intname, 1);
        delete sto;
    }
}

//Redeclares the vars in varlist by pushing them to outlist
//Note: Array types make this function confusing. If a variable is declared as int b[5], its entry in the varList will just be "b"
//All variables should be in the hashmap, so if we don't find "b", assume we're looking for "b["
void redeclareVars(strvec& varList, strvec& outList)
{
	for (int i = 0; i < varList.size(); i++)
	{
		std::string typeStr;
		std::string newLine;

		if (varsAndTypes.find(varList.at(i)) == varsAndTypes.end()) //if the var not there, should be array type
		{
			std::string varNameStr = varList.at(i);
			varNameStr = varNameStr.append("["); //add this to look for array types
			for (std::map<std::string, std::string>::iterator it = varsAndTypes.begin(); it != varsAndTypes.end(); it++)
			{
				if (it->first.substr(0, varNameStr.length()).compare(varNameStr) == 0) //if varnamestr is b[ and the entry in the map starts with b[, we've found it
				{
					//we want to declare it as int b[5], so we still need the type
					typeStr = it->second;
					std::string varNameStr = it->first;
					newLine = typeStr.append(" ").append(varNameStr).append(";");
				}
			}
		}
		else //if it's in there, append like always
		{
			typeStr = varsAndTypes[varList.at(i)];
			newLine = typeStr.append(" ").append(varList.at(i)).append(";");
		}

		outList.push_back(newLine);
	}
}

//Pushes the vecRef into input after the include statements (at the top)
void insertAfterIncludes(strvec& vecRef)
{
	//move past any includes
	int i;
	for (i = 0; i < input.size(); i++)
	{
		if (input.at(i).length() > 0 && input.at(i).at(0) != '#')
		{
			break;
		}
	}

	//once we're here, we're past the includes and we can copy the new function
	//we need to insert this in reverse order
	for (int j = vecRef.size()-1; j >= 0; j--)
	{
		input.insert(input.begin() + i, vecRef.at(j));
	}
}

void Matrix::select(strvec &rv, strvec &names, bool(Matrix::*fun)(string)const, strvec &ignore)const {
    if (names.empty())
        names = rows;
    elmap::iterator end = map->end();
    string name;
    strvec::iterator igbeg = ignore.begin(), igend = ignore.end();
    for (strvec::iterator it = names.begin(); it != names.end(); ++it){        
        if (std::find(igbeg, igend, *it) == igend){
            name = *it;
            if (map->find(*it) == end)
                throw runtime_error(string("No such row or column: ") + name);
            if ((*this.*fun)(name))
                rv.push_back(name);
        }
    }
}

//Declares the varlist in the main function
void declarePrivatesInMain(strvec& varList)
{
	int mainLine = 0;
	for (mainLine; mainLine < input.size(); mainLine++)
	{
		std::string curStr = input.at(mainLine);
		if (curStr.compare("int main()") == 0)
		{
			break;
		}
	}

	mainLine += 2; //move past brackets
	for (int i = 0; i < varList.size(); i++)
	{
		input.insert(input.begin() + mainLine++, varList.at(i));
	}
}

void MtxLP::ko(OBJSTAT& rv, stomap* obj, strvec blockvec, bool max, bool presolve){
    block(&blockvec, true);
    getOptObjStat(rv, obj, max, presolve);
    cleanTmpRows(blockvec.size());
}