Tomaž Vajngerl
bfc9cfdecf
The Lpsolve solver and the CoinMP solver are both used for the same thing: a linear model, with optional integer variables by branch and bound. CoinMP (CLP plus CBC) is the more capable and better maintained of the two, so the lp_solve one adds a second bundled dependency and a parallel copy of the solver code for no capability the other lacks. Remove the LpsolveSolver component, the bundled lp_solve external (and its colamd dependency, which only lp_solve used), and all the build, configure, packaging and license references to them. A document may still name com.sun.star.comp.Calc.LpsolveSolver as its engine. SolverSettings now reads that name as the CoinMP solver, which solves the same model, so such documents keep working. The Calc solver test that exercised the engine now uses CoinMP. Its knapsack model has a single optimal total value of 6987, which fills the weight capacity of 1000 exactly and which CoinMP finds. The lp_solve run had returned a suboptimal 6981, so the test now expects the true optimum. The build setup changes only take effect after re-running autogen. Signed-off-by: Tomaž Vajngerl <tomaz.vajngerl@collabora.co.uk> Change-Id: Ia14d8c491779873da6b0157aa524056275adf8f5 Reviewed-on: https://gerrit.collaboraoffice.com/c/online/+/3810 Reviewed-by: Miklos Vajna <vmiklos@collabora.com> Tested-by: Jenkins CPCI <releng@collaboraoffice.com> (cherry picked from commit e77738a7ca7d44fd9d1f852e26d46e3a6d60467b) Reviewed-on: https://gerrit.libreoffice.org/c/core/+/208038 Tested-by: Jenkins Reviewed-by: Xisco Fauli <xiscofauli@libreoffice.org>
814 lines
28 KiB
C++
814 lines
28 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
*/
|
|
|
|
#include <global.hxx>
|
|
#include <compiler.hxx>
|
|
#include <table.hxx>
|
|
#include <docsh.hxx>
|
|
#include <rtl/math.hxx>
|
|
#include <o3tl/string_view.hxx>
|
|
#include <solverutil.hxx>
|
|
#include <unotools/charclass.hxx>
|
|
#include <SolverSettings.hxx>
|
|
|
|
namespace sc
|
|
{
|
|
SolverSettings::SolverSettings(ScTable& rTable)
|
|
: m_rTable(rTable)
|
|
, m_rDoc(m_rTable.GetDoc())
|
|
, m_pDocShell(m_rDoc.GetDocumentShell())
|
|
{
|
|
// Get the named range manager for this tab
|
|
std::map<OUString, ScRangeName*> rRangeMap;
|
|
m_rDoc.GetRangeNameMap(rRangeMap);
|
|
m_pRangeName = rRangeMap.find(m_rTable.GetName())->second;
|
|
|
|
Initialize();
|
|
}
|
|
|
|
void SolverSettings::Initialize()
|
|
{
|
|
// Assign default values for the solver parameters
|
|
ResetToDefaults();
|
|
|
|
// Read the parameter values in the sheet
|
|
ReadParamValue(SP_OBJ_CELL, m_sObjCell);
|
|
ReadParamValue(SP_OBJ_VAL, m_sObjVal);
|
|
ReadParamValue(SP_VAR_CELLS, m_sVariableCells);
|
|
|
|
// Read the objective type
|
|
OUString sObjType;
|
|
if (ReadParamValue(SP_OBJ_TYPE, sObjType))
|
|
{
|
|
switch (sObjType.toInt32())
|
|
{
|
|
case 1:
|
|
m_eObjType = ObjectiveType::OT_MAXIMIZE;
|
|
break;
|
|
case 2:
|
|
m_eObjType = ObjectiveType::OT_MINIMIZE;
|
|
break;
|
|
case 3:
|
|
m_eObjType = ObjectiveType::OT_VALUE;
|
|
break;
|
|
default:
|
|
m_eObjType = ObjectiveType::OT_MAXIMIZE;
|
|
}
|
|
}
|
|
|
|
// Read all constraints in the tab
|
|
ReadConstraints();
|
|
|
|
// Read the solver engine being used
|
|
ReadEngine();
|
|
|
|
// Read engine options
|
|
ReadParamValue(SP_INTEGER, m_sInteger);
|
|
ReadParamValue(SP_NON_NEGATIVE, m_sNonNegative);
|
|
ReadParamValue(SP_EPSILON_LEVEL, m_sEpsilonLevel);
|
|
ReadParamValue(SP_LIMIT_BBDEPTH, m_sLimitBBDepth);
|
|
ReadParamValue(SP_TIMEOUT, m_sTimeout);
|
|
ReadParamValue(SP_ALGORITHM, m_sAlgorithm);
|
|
// Engine options common for DEPS and SCO
|
|
ReadParamValue(SP_SWARM_SIZE, m_sSwarmSize);
|
|
ReadParamValue(SP_LEARNING_CYCLES, m_sLearningCycles);
|
|
ReadParamValue(SP_GUESS_VARIABLE_RANGE, m_sGuessVariableRange);
|
|
ReadDoubleParamValue(SP_VARIABLE_RANGE_THRESHOLD, m_sVariableRangeThreshold);
|
|
ReadParamValue(SP_ACR_COMPARATOR, m_sUseACRComparator);
|
|
ReadParamValue(SP_RND_STARTING_POINT, m_sUseRandomStartingPoint);
|
|
ReadParamValue(SP_STRONGER_PRNG, m_sUseStrongerPRNG);
|
|
ReadParamValue(SP_STAGNATION_LIMIT, m_sStagnationLimit);
|
|
ReadDoubleParamValue(SP_STAGNATION_TOLERANCE, m_sTolerance);
|
|
ReadParamValue(SP_ENHANCED_STATUS, m_sEnhancedSolverStatus);
|
|
// DEPS Options
|
|
ReadDoubleParamValue(SP_AGENT_SWITCH_RATE, m_sAgentSwitchRate);
|
|
ReadDoubleParamValue(SP_SCALING_MIN, m_sScalingFactorMin);
|
|
ReadDoubleParamValue(SP_SCALING_MAX, m_sScalingFactorMax);
|
|
ReadDoubleParamValue(SP_CROSSOVER_PROB, m_sCrossoverProbability);
|
|
ReadDoubleParamValue(SP_COGNITIVE_CONST, m_sCognitiveConstant);
|
|
ReadDoubleParamValue(SP_SOCIAL_CONST, m_sSocialConstant);
|
|
ReadDoubleParamValue(SP_CONSTRICTION_COEFF, m_sConstrictionCoeff);
|
|
ReadDoubleParamValue(SP_MUTATION_PROB, m_sMutationProbability);
|
|
// SCO Options
|
|
ReadParamValue(SP_LIBRARY_SIZE, m_sLibrarySize);
|
|
}
|
|
|
|
// Returns the current value of the parameter in the object as a string
|
|
OUString SolverSettings::GetParameter(SolverParameter eParam)
|
|
{
|
|
switch (eParam)
|
|
{
|
|
case SP_OBJ_CELL:
|
|
return m_sObjCell;
|
|
break;
|
|
case SP_OBJ_TYPE:
|
|
return OUString::number(m_eObjType);
|
|
break;
|
|
case SP_OBJ_VAL:
|
|
return m_sObjVal;
|
|
break;
|
|
case SP_VAR_CELLS:
|
|
return m_sVariableCells;
|
|
break;
|
|
case SP_CONSTR_COUNT:
|
|
return OUString::number(m_aConstraints.size());
|
|
break;
|
|
case SP_LO_ENGINE:
|
|
return m_sLOEngineName;
|
|
break;
|
|
case SP_MS_ENGINE:
|
|
return m_sMSEngineId;
|
|
break;
|
|
case SP_INTEGER:
|
|
return m_sInteger;
|
|
break;
|
|
case SP_NON_NEGATIVE:
|
|
return m_sNonNegative;
|
|
break;
|
|
case SP_EPSILON_LEVEL:
|
|
return m_sEpsilonLevel;
|
|
break;
|
|
case SP_LIMIT_BBDEPTH:
|
|
return m_sLimitBBDepth;
|
|
break;
|
|
case SP_TIMEOUT:
|
|
return m_sTimeout;
|
|
break;
|
|
case SP_ALGORITHM:
|
|
return m_sAlgorithm;
|
|
break;
|
|
case SP_SWARM_SIZE:
|
|
return m_sSwarmSize;
|
|
break;
|
|
case SP_LEARNING_CYCLES:
|
|
return m_sLearningCycles;
|
|
break;
|
|
case SP_GUESS_VARIABLE_RANGE:
|
|
return m_sGuessVariableRange;
|
|
break;
|
|
case SP_VARIABLE_RANGE_THRESHOLD:
|
|
return m_sVariableRangeThreshold;
|
|
break;
|
|
case SP_ACR_COMPARATOR:
|
|
return m_sUseACRComparator;
|
|
break;
|
|
case SP_RND_STARTING_POINT:
|
|
return m_sUseRandomStartingPoint;
|
|
break;
|
|
case SP_STRONGER_PRNG:
|
|
return m_sUseStrongerPRNG;
|
|
break;
|
|
case SP_STAGNATION_LIMIT:
|
|
return m_sStagnationLimit;
|
|
break;
|
|
case SP_STAGNATION_TOLERANCE:
|
|
return m_sTolerance;
|
|
break;
|
|
case SP_ENHANCED_STATUS:
|
|
return m_sEnhancedSolverStatus;
|
|
break;
|
|
case SP_AGENT_SWITCH_RATE:
|
|
return m_sAgentSwitchRate;
|
|
break;
|
|
case SP_SCALING_MIN:
|
|
return m_sScalingFactorMin;
|
|
break;
|
|
case SP_SCALING_MAX:
|
|
return m_sScalingFactorMax;
|
|
break;
|
|
case SP_CROSSOVER_PROB:
|
|
return m_sCrossoverProbability;
|
|
break;
|
|
case SP_COGNITIVE_CONST:
|
|
return m_sCognitiveConstant;
|
|
break;
|
|
case SP_SOCIAL_CONST:
|
|
return m_sSocialConstant;
|
|
break;
|
|
case SP_CONSTRICTION_COEFF:
|
|
return m_sConstrictionCoeff;
|
|
break;
|
|
case SP_MUTATION_PROB:
|
|
return m_sMutationProbability;
|
|
break;
|
|
case SP_LIBRARY_SIZE:
|
|
return m_sLibrarySize;
|
|
break;
|
|
default:
|
|
return u""_ustr;
|
|
}
|
|
}
|
|
|
|
// Sets the value of a single solver parameter in the object
|
|
void SolverSettings::SetParameter(SolverParameter eParam, const OUString& sValue)
|
|
{
|
|
switch (eParam)
|
|
{
|
|
case SP_OBJ_CELL:
|
|
m_sObjCell = sValue;
|
|
break;
|
|
case SP_OBJ_TYPE:
|
|
{
|
|
sal_Int32 nObjType = sValue.toInt32();
|
|
switch (nObjType)
|
|
{
|
|
case OT_MAXIMIZE:
|
|
m_eObjType = ObjectiveType::OT_MAXIMIZE;
|
|
break;
|
|
case OT_MINIMIZE:
|
|
m_eObjType = ObjectiveType::OT_MINIMIZE;
|
|
break;
|
|
case OT_VALUE:
|
|
m_eObjType = ObjectiveType::OT_VALUE;
|
|
break;
|
|
default:
|
|
m_eObjType = ObjectiveType::OT_MAXIMIZE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case SP_OBJ_VAL:
|
|
m_sObjVal = sValue;
|
|
break;
|
|
case SP_VAR_CELLS:
|
|
m_sVariableCells = sValue;
|
|
break;
|
|
case SP_LO_ENGINE:
|
|
m_sLOEngineName = sValue;
|
|
break;
|
|
case SP_INTEGER:
|
|
{
|
|
if (sValue == "0" || sValue == "1")
|
|
m_sInteger = sValue;
|
|
}
|
|
break;
|
|
case SP_NON_NEGATIVE:
|
|
{
|
|
if (sValue == "1" || sValue == "2")
|
|
m_sNonNegative = sValue;
|
|
}
|
|
break;
|
|
case SP_EPSILON_LEVEL:
|
|
m_sEpsilonLevel = sValue;
|
|
break;
|
|
case SP_LIMIT_BBDEPTH:
|
|
m_sLimitBBDepth = sValue;
|
|
break;
|
|
case SP_TIMEOUT:
|
|
m_sTimeout = sValue;
|
|
break;
|
|
case SP_ALGORITHM:
|
|
{
|
|
if (sValue == "1" || sValue == "2" || sValue == "3")
|
|
m_sAlgorithm = sValue;
|
|
}
|
|
break;
|
|
case SP_SWARM_SIZE:
|
|
m_sSwarmSize = sValue;
|
|
break;
|
|
case SP_LEARNING_CYCLES:
|
|
m_sLearningCycles = sValue;
|
|
break;
|
|
case SP_GUESS_VARIABLE_RANGE:
|
|
m_sGuessVariableRange = sValue;
|
|
break;
|
|
case SP_VARIABLE_RANGE_THRESHOLD:
|
|
m_sVariableRangeThreshold = sValue;
|
|
break;
|
|
case SP_ACR_COMPARATOR:
|
|
{
|
|
if (sValue == "0" || sValue == "1")
|
|
m_sUseACRComparator = sValue;
|
|
}
|
|
break;
|
|
case SP_RND_STARTING_POINT:
|
|
{
|
|
if (sValue == "0" || sValue == "1")
|
|
m_sUseRandomStartingPoint = sValue;
|
|
}
|
|
break;
|
|
case SP_STRONGER_PRNG:
|
|
{
|
|
if (sValue == "0" || sValue == "1")
|
|
m_sUseStrongerPRNG = sValue;
|
|
}
|
|
break;
|
|
case SP_STAGNATION_LIMIT:
|
|
m_sStagnationLimit = sValue;
|
|
break;
|
|
case SP_STAGNATION_TOLERANCE:
|
|
m_sTolerance = sValue;
|
|
break;
|
|
case SP_ENHANCED_STATUS:
|
|
{
|
|
if (sValue == "0" || sValue == "1")
|
|
m_sEnhancedSolverStatus = sValue;
|
|
}
|
|
break;
|
|
case SP_AGENT_SWITCH_RATE:
|
|
m_sAgentSwitchRate = sValue;
|
|
break;
|
|
case SP_SCALING_MIN:
|
|
m_sScalingFactorMin = sValue;
|
|
break;
|
|
case SP_SCALING_MAX:
|
|
m_sScalingFactorMax = sValue;
|
|
break;
|
|
case SP_CROSSOVER_PROB:
|
|
m_sCrossoverProbability = sValue;
|
|
break;
|
|
case SP_COGNITIVE_CONST:
|
|
m_sCognitiveConstant = sValue;
|
|
break;
|
|
case SP_SOCIAL_CONST:
|
|
m_sSocialConstant = sValue;
|
|
break;
|
|
case SP_CONSTRICTION_COEFF:
|
|
m_sConstrictionCoeff = sValue;
|
|
break;
|
|
case SP_MUTATION_PROB:
|
|
m_sMutationProbability = sValue;
|
|
break;
|
|
case SP_LIBRARY_SIZE:
|
|
m_sLibrarySize = sValue;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SolverSettings::SetObjectiveType(ObjectiveType eType) { m_eObjType = eType; }
|
|
|
|
// Loads all constraints in the tab
|
|
void SolverSettings::ReadConstraints()
|
|
{
|
|
// Condition indices start at 1 for MS compatibility
|
|
// The number of "lhs", "rel" and "rhs" entries will always be the same
|
|
tools::Long nConstraint = 1;
|
|
m_aConstraints.clear();
|
|
OUString sValue;
|
|
|
|
while (ReadConstraintPart(CP_LEFT_HAND_SIDE, nConstraint, sValue))
|
|
{
|
|
// Left hand side
|
|
ModelConstraint aNewCondition;
|
|
aNewCondition.aLeftStr = sValue;
|
|
|
|
// Right hand side
|
|
if (ReadConstraintPart(CP_RIGHT_HAND_SIDE, nConstraint, sValue))
|
|
aNewCondition.aRightStr = sValue;
|
|
|
|
// Relation (operator)
|
|
if (ReadConstraintPart(CP_OPERATOR, nConstraint, sValue))
|
|
aNewCondition.nOperator = static_cast<sc::ConstraintOperator>(sValue.toInt32());
|
|
|
|
m_aConstraints.push_back(aNewCondition);
|
|
nConstraint++;
|
|
}
|
|
}
|
|
|
|
// Writes all constraints to the file
|
|
void SolverSettings::WriteConstraints()
|
|
{
|
|
// Condition indices start at 1 for MS compatibility
|
|
tools::Long nConstraint = 1;
|
|
|
|
for (auto& aConstraint : m_aConstraints)
|
|
{
|
|
// Left hand side
|
|
WriteConstraintPart(CP_LEFT_HAND_SIDE, nConstraint, aConstraint.aLeftStr);
|
|
// Relation (operator)
|
|
WriteConstraintPart(CP_OPERATOR, nConstraint, OUString::number(aConstraint.nOperator));
|
|
// Right hand side
|
|
WriteConstraintPart(CP_RIGHT_HAND_SIDE, nConstraint, aConstraint.aRightStr);
|
|
nConstraint++;
|
|
}
|
|
}
|
|
|
|
// Write a single constraint part to the file
|
|
void SolverSettings::WriteConstraintPart(ConstraintPart ePart, tools::Long nIndex,
|
|
const OUString& sValue)
|
|
{
|
|
// Empty named ranges cannot be written to the file (this corrupts MS files)
|
|
if (sValue.isEmpty())
|
|
return;
|
|
|
|
OUString sRange = m_aConstraintParts[ePart] + OUString::number(nIndex);
|
|
ScRangeData* pNewEntry = new ScRangeData(m_rDoc, sRange, sValue);
|
|
pNewEntry->AddType(ScRangeData::Type::Hidden);
|
|
m_pRangeName->insert(pNewEntry);
|
|
}
|
|
|
|
// Reads a single constraint part from its associated named range; returns false if the named
|
|
// range does not exist in the file
|
|
bool SolverSettings::ReadConstraintPart(ConstraintPart ePart, tools::Long nIndex, OUString& rValue)
|
|
{
|
|
OUString sRange = m_aConstraintParts[ePart] + OUString::number(nIndex);
|
|
ScRangeData* pRangeData
|
|
= m_pRangeName->findByUpperName(ScGlobal::getCharClass().uppercase(sRange));
|
|
if (pRangeData)
|
|
{
|
|
rValue = pRangeData->GetSymbol();
|
|
// tdf#156814 Remove sheet name if it is a range that refers to the same sheet
|
|
ScRange aRange;
|
|
ScRefFlags nFlags = aRange.ParseAny(rValue, m_rDoc);
|
|
bool bIsValidRange = (nFlags & ScRefFlags::VALID) == ScRefFlags::VALID;
|
|
if (bIsValidRange && m_rTable.GetTab() == aRange.aStart.Tab())
|
|
rValue = aRange.Format(m_rDoc, ScRefFlags::RANGE_ABS);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Reads the engine name parameter as informed in the file in the format used in LO.
|
|
* If only a MS engine is informed, then it is converted to a LO-equivalent engine
|
|
*/
|
|
void SolverSettings::ReadEngine()
|
|
{
|
|
if (!ReadParamValue(SP_LO_ENGINE, m_sLOEngineName, true))
|
|
{
|
|
// If no engine is defined, use CoinMP solver as default
|
|
m_sLOEngineName = "com.sun.star.comp.Calc.CoinMPSolver";
|
|
}
|
|
|
|
// The Lpsolve solver has been removed. A document that still names it is
|
|
// solved by CoinMP, which handles the same linear models.
|
|
if (m_sLOEngineName == "com.sun.star.comp.Calc.LpsolveSolver")
|
|
m_sLOEngineName = u"com.sun.star.comp.Calc.CoinMPSolver"_ustr;
|
|
|
|
if (SolverNamesToExcelEngines.count(m_sLOEngineName))
|
|
{
|
|
// Find equivalent MS engine code
|
|
m_sMSEngineId = SolverNamesToExcelEngines.find(m_sLOEngineName)->second;
|
|
}
|
|
}
|
|
|
|
// Write solver LO and MS-equivalent engine names
|
|
void SolverSettings::WriteEngine()
|
|
{
|
|
WriteParamValue(SP_LO_ENGINE, m_sLOEngineName, true);
|
|
// Find equivalent MS engine code
|
|
if (SolverNamesToExcelEngines.count(m_sLOEngineName))
|
|
{
|
|
m_sMSEngineId = SolverNamesToExcelEngines.find(m_sLOEngineName)->second;
|
|
WriteParamValue(SP_MS_ENGINE, m_sMSEngineId);
|
|
}
|
|
}
|
|
|
|
// Assigns a new constraints vector
|
|
void SolverSettings::SetConstraints(std::vector<ModelConstraint> aConstraints)
|
|
{
|
|
m_aConstraints = std::move(aConstraints);
|
|
}
|
|
|
|
// Saves all solver settings into the file
|
|
void SolverSettings::SaveSolverSettings()
|
|
{
|
|
// Before saving, remove all existing named ranges related to the solver
|
|
DeleteAllNamedRanges();
|
|
|
|
WriteParamValue(SP_OBJ_CELL, m_sObjCell);
|
|
WriteParamValue(SP_OBJ_TYPE, OUString::number(m_eObjType));
|
|
WriteParamValue(SP_OBJ_VAL, m_sObjVal);
|
|
WriteParamValue(SP_VAR_CELLS, m_sVariableCells);
|
|
|
|
WriteConstraints();
|
|
WriteEngine();
|
|
|
|
sal_Int32 nConstrCount = m_aConstraints.size();
|
|
WriteParamValue(SP_CONSTR_COUNT, OUString::number(nConstrCount));
|
|
|
|
// Solver engine options
|
|
WriteParamValue(SP_INTEGER, m_sInteger);
|
|
WriteParamValue(SP_NON_NEGATIVE, m_sNonNegative);
|
|
WriteParamValue(SP_EPSILON_LEVEL, m_sEpsilonLevel);
|
|
WriteParamValue(SP_LIMIT_BBDEPTH, m_sLimitBBDepth);
|
|
WriteParamValue(SP_TIMEOUT, m_sTimeout);
|
|
WriteParamValue(SP_ALGORITHM, m_sAlgorithm);
|
|
// Engine options common for DEPS and SCO
|
|
WriteParamValue(SP_SWARM_SIZE, m_sSwarmSize);
|
|
WriteParamValue(SP_LEARNING_CYCLES, m_sLearningCycles);
|
|
WriteParamValue(SP_GUESS_VARIABLE_RANGE, m_sGuessVariableRange);
|
|
WriteDoubleParamValue(SP_VARIABLE_RANGE_THRESHOLD, m_sVariableRangeThreshold);
|
|
WriteParamValue(SP_ACR_COMPARATOR, m_sUseACRComparator);
|
|
WriteParamValue(SP_RND_STARTING_POINT, m_sUseRandomStartingPoint);
|
|
WriteParamValue(SP_STRONGER_PRNG, m_sUseStrongerPRNG);
|
|
WriteParamValue(SP_STAGNATION_LIMIT, m_sStagnationLimit);
|
|
WriteDoubleParamValue(SP_STAGNATION_TOLERANCE, m_sTolerance);
|
|
WriteParamValue(SP_ENHANCED_STATUS, m_sEnhancedSolverStatus);
|
|
// DEPS Options
|
|
WriteDoubleParamValue(SP_AGENT_SWITCH_RATE, m_sAgentSwitchRate);
|
|
WriteDoubleParamValue(SP_SCALING_MIN, m_sScalingFactorMin);
|
|
WriteDoubleParamValue(SP_SCALING_MAX, m_sScalingFactorMax);
|
|
WriteDoubleParamValue(SP_CROSSOVER_PROB, m_sCrossoverProbability);
|
|
WriteDoubleParamValue(SP_COGNITIVE_CONST, m_sCognitiveConstant);
|
|
WriteDoubleParamValue(SP_SOCIAL_CONST, m_sSocialConstant);
|
|
WriteDoubleParamValue(SP_CONSTRICTION_COEFF, m_sConstrictionCoeff);
|
|
WriteDoubleParamValue(SP_MUTATION_PROB, m_sMutationProbability);
|
|
// SCO Options
|
|
WriteParamValue(SP_LIBRARY_SIZE, m_sLibrarySize);
|
|
|
|
if (m_pDocShell)
|
|
m_pDocShell->SetDocumentModified();
|
|
}
|
|
|
|
/* Reads the current value of the parameter in the named range into rValue
|
|
* If the value does not exist, the rValue is left unchanged
|
|
* This is private because it is only used during initialization
|
|
* Returns true if the value exits; returns false otherwise
|
|
*/
|
|
bool SolverSettings::ReadParamValue(SolverParameter eParam, OUString& rValue, bool bRemoveQuotes)
|
|
{
|
|
const auto iter = m_mNamedRanges.find(eParam);
|
|
assert(iter != m_mNamedRanges.end());
|
|
OUString sRange = iter->second;
|
|
ScRangeData* pRangeData
|
|
= m_pRangeName->findByUpperName(ScGlobal::getCharClass().uppercase(sRange));
|
|
if (pRangeData)
|
|
{
|
|
rValue = pRangeData->GetSymbol();
|
|
if (bRemoveQuotes)
|
|
ScGlobal::EraseQuotes(rValue, '"');
|
|
|
|
// tdf#156814 Remove sheet name from the objective cell and value if they refer to the same sheet
|
|
if (eParam == SP_OBJ_CELL || eParam == SP_OBJ_VAL)
|
|
{
|
|
ScRange aRange;
|
|
ScRefFlags nFlags = aRange.ParseAny(rValue, m_rDoc);
|
|
bool bIsValidRange = ((nFlags & ScRefFlags::VALID) == ScRefFlags::VALID);
|
|
|
|
if (bIsValidRange && m_rTable.GetTab() == aRange.aStart.Tab())
|
|
rValue = aRange.Format(m_rDoc, ScRefFlags::RANGE_ABS);
|
|
}
|
|
else if (eParam == SP_VAR_CELLS)
|
|
{
|
|
// Variable cells may contain multiple ranges separated by ';'
|
|
sal_Int32 nIdx = 0;
|
|
OUString sNewValue;
|
|
bool bFirst = true;
|
|
// Delimiter character to separate ranges
|
|
sal_Unicode cDelimiter = ScCompiler::GetNativeSymbolChar(OpCode::ocSep);
|
|
|
|
do
|
|
{
|
|
OUString aRangeStr(o3tl::getToken(rValue, 0, cDelimiter, nIdx));
|
|
ScRange aRange;
|
|
ScRefFlags nFlags = aRange.ParseAny(aRangeStr, m_rDoc);
|
|
bool bIsValidRange = (nFlags & ScRefFlags::VALID) == ScRefFlags::VALID;
|
|
|
|
if (bIsValidRange && m_rTable.GetTab() == aRange.aStart.Tab())
|
|
aRangeStr = aRange.Format(m_rDoc, ScRefFlags::RANGE_ABS);
|
|
|
|
if (bFirst)
|
|
{
|
|
sNewValue = aRangeStr;
|
|
bFirst = false;
|
|
}
|
|
else
|
|
{
|
|
sNewValue += OUStringChar(cDelimiter) + aRangeStr;
|
|
}
|
|
} while (nIdx > 0);
|
|
|
|
rValue = sNewValue;
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Reads a parameter value of type 'double' from the named range and into rValue
|
|
bool SolverSettings::ReadDoubleParamValue(SolverParameter eParam, OUString& rValue)
|
|
{
|
|
const auto iter = m_mNamedRanges.find(eParam);
|
|
assert(iter != m_mNamedRanges.end());
|
|
OUString sRange = iter->second;
|
|
ScRangeData* pRangeData
|
|
= m_pRangeName->findByUpperName(ScGlobal::getCharClass().uppercase(sRange));
|
|
if (pRangeData)
|
|
{
|
|
OUString sLocalizedValue = pRangeData->GetSymbol();
|
|
double fValue = rtl::math::stringToDouble(sLocalizedValue,
|
|
ScGlobal::getLocaleData().getNumDecimalSep()[0],
|
|
ScGlobal::getLocaleData().getNumThousandSep()[0]);
|
|
rValue = OUString::number(fValue);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Writes a parameter value to the file as a named range.
|
|
* Argument bQuoted indicates whether the value should be enclosed with quotes or not (used
|
|
* for string expressions that must be enclosed with quotes)
|
|
*/
|
|
void SolverSettings::WriteParamValue(SolverParameter eParam, OUString sValue, bool bQuoted)
|
|
{
|
|
// Empty parameters cannot be written to the file (this corrupts MS files)
|
|
// There's no problem if the parameter is missing both for LO and MS
|
|
if (sValue.isEmpty())
|
|
return;
|
|
|
|
if (bQuoted)
|
|
ScGlobal::AddQuotes(sValue, '"');
|
|
|
|
const auto iter = m_mNamedRanges.find(eParam);
|
|
assert(iter != m_mNamedRanges.end());
|
|
OUString sRange = iter->second;
|
|
ScRangeData* pNewEntry = new ScRangeData(m_rDoc, sRange, sValue);
|
|
pNewEntry->AddType(ScRangeData::Type::Hidden);
|
|
m_pRangeName->insert(pNewEntry);
|
|
}
|
|
|
|
// Writes a parameter value of type 'double' to the file as a named range
|
|
// The argument 'sValue' uses dot as decimal separator and needs to be localized before
|
|
// being written to the file
|
|
void SolverSettings::WriteDoubleParamValue(SolverParameter eParam, std::u16string_view sValue)
|
|
{
|
|
const auto iter = m_mNamedRanges.find(eParam);
|
|
assert(iter != m_mNamedRanges.end());
|
|
OUString sRange = iter->second;
|
|
double fValue = rtl::math::stringToDouble(sValue, '.', ',');
|
|
OUString sLocalizedValue = rtl::math::doubleToUString(
|
|
fValue, rtl_math_StringFormat_Automatic, rtl_math_DecimalPlaces_Max,
|
|
ScGlobal::getLocaleData().getNumDecimalSep()[0], true);
|
|
ScRangeData* pNewEntry = new ScRangeData(m_rDoc, sRange, sLocalizedValue);
|
|
pNewEntry->AddType(ScRangeData::Type::Hidden);
|
|
m_pRangeName->insert(pNewEntry);
|
|
}
|
|
|
|
void SolverSettings::GetEngineOptions(css::uno::Sequence<css::beans::PropertyValue>& aOptions)
|
|
{
|
|
sal_Int32 nOptionsSize = aOptions.getLength();
|
|
auto pParamValues = aOptions.getArray();
|
|
|
|
for (auto i = 0; i < nOptionsSize; i++)
|
|
{
|
|
const css::beans::PropertyValue& aProp = aOptions[i];
|
|
OUString sLOParamName = aProp.Name;
|
|
// Only try to get the parameter value if it is an expected parameter name
|
|
if (SolverParamNames.count(sLOParamName))
|
|
{
|
|
TParamInfo aParamInfo;
|
|
aParamInfo = SolverParamNames.find(sLOParamName)->second;
|
|
SolverParameter eParamId = std::get<SolverParameter>(aParamInfo[0]);
|
|
OUString sParamType = std::get<OUString>(aParamInfo[2]);
|
|
OUString sParamValue = GetParameter(eParamId);
|
|
if (sParamType == "int")
|
|
{
|
|
css::uno::Any nValue(sParamValue.toInt32());
|
|
pParamValues[i] = css::beans::PropertyValue(sLOParamName, -1, nValue,
|
|
css::beans::PropertyState_DIRECT_VALUE);
|
|
}
|
|
if (sParamType == "double")
|
|
{
|
|
css::uno::Any fValue(sParamValue.toDouble());
|
|
pParamValues[i] = css::beans::PropertyValue(sLOParamName, -1, fValue,
|
|
css::beans::PropertyState_DIRECT_VALUE);
|
|
}
|
|
if (sParamType == "bool")
|
|
{
|
|
// The parameter NonNegative is a special case for MS compatibility
|
|
// It uses "1" for "true" and "2" for "false"
|
|
bool bTmpValue;
|
|
if (sLOParamName == "NonNegative")
|
|
bTmpValue = sParamValue == "1" ? true : false;
|
|
else
|
|
bTmpValue = sParamValue.toBoolean();
|
|
|
|
css::uno::Any bValue(bTmpValue);
|
|
pParamValues[i] = css::beans::PropertyValue(sLOParamName, -1, bValue,
|
|
css::beans::PropertyState_DIRECT_VALUE);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Updates the object members related to solver engine options using aOptions info
|
|
void SolverSettings::SetEngineOptions(const css::uno::Sequence<css::beans::PropertyValue>& aOptions)
|
|
{
|
|
sal_Int32 nOptionsSize = aOptions.getLength();
|
|
|
|
for (auto i = 0; i < nOptionsSize; i++)
|
|
{
|
|
const css::beans::PropertyValue& aProp = aOptions[i];
|
|
OUString sLOParamName = aProp.Name;
|
|
// Only try to set the parameter value if it is an expected parameter name
|
|
if (SolverParamNames.count(sLOParamName))
|
|
{
|
|
TParamInfo aParamInfo;
|
|
aParamInfo = SolverParamNames.find(sLOParamName)->second;
|
|
SolverParameter eParamId = std::get<SolverParameter>(aParamInfo[0]);
|
|
OUString sParamType = std::get<OUString>(aParamInfo[2]);
|
|
if (sParamType == "int")
|
|
{
|
|
sal_Int32 nValue = 0;
|
|
aProp.Value >>= nValue;
|
|
SetParameter(eParamId, OUString::number(nValue));
|
|
}
|
|
if (sParamType == "double")
|
|
{
|
|
double fValue = 0;
|
|
aProp.Value >>= fValue;
|
|
SetParameter(eParamId, OUString::number(fValue));
|
|
}
|
|
if (sParamType == "bool")
|
|
{
|
|
bool bValue = false;
|
|
aProp.Value >>= bValue;
|
|
if (sLOParamName == "NonNegative")
|
|
{
|
|
// The parameter NonNegative is a special case for MS compatibility
|
|
// It uses "1" for "true" and "2" for "false"
|
|
if (bValue)
|
|
SetParameter(eParamId, OUString::number(1));
|
|
else
|
|
SetParameter(eParamId, OUString::number(2));
|
|
}
|
|
else
|
|
{
|
|
SetParameter(eParamId, OUString::number(sal_Int32(bValue)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Deletes all named ranges in the current tab that are related to the solver (i.e. start with "solver_")
|
|
void SolverSettings::DeleteAllNamedRanges()
|
|
{
|
|
std::vector<ScRangeData*> aItemsToErase;
|
|
|
|
// Indices in m_pRangeName start at 1
|
|
for (size_t i = 1; i <= m_pRangeName->size(); ++i)
|
|
{
|
|
ScRangeData* pData = m_pRangeName->findByIndex(i);
|
|
if (pData && pData->GetName().startsWith("solver_"))
|
|
aItemsToErase.push_back(pData);
|
|
}
|
|
|
|
for (auto pItem : aItemsToErase)
|
|
m_pRangeName->erase(*pItem);
|
|
}
|
|
|
|
/* Sets all solver parameters to their default values and clear all constraints.
|
|
* This method only resets the object properties, but does not save changes to the
|
|
* document. To save changes, call SaveSolverSettings().
|
|
*/
|
|
void SolverSettings::ResetToDefaults()
|
|
{
|
|
m_sObjCell = "";
|
|
m_eObjType = ObjectiveType::OT_MAXIMIZE;
|
|
m_sObjVal = "";
|
|
m_sVariableCells = "";
|
|
m_sMSEngineId = "1";
|
|
|
|
css::uno::Sequence<OUString> aEngineNames;
|
|
css::uno::Sequence<OUString> aDescriptions;
|
|
ScSolverUtil::GetImplementations(aEngineNames, aDescriptions);
|
|
|
|
// tdf#162760 Set the parameters of all available solver engines to the default values
|
|
for (const auto& sEngine : aEngineNames)
|
|
{
|
|
css::uno::Sequence<css::beans::PropertyValue> aEngineProps
|
|
= ScSolverUtil::GetDefaults(sEngine);
|
|
SetEngineOptions(aEngineProps);
|
|
}
|
|
|
|
// The default solver engine is the first implementation available
|
|
m_sLOEngineName = aEngineNames[0];
|
|
|
|
// Clear all constraints
|
|
m_aConstraints.clear();
|
|
}
|
|
|
|
/* Returns true if the current sheet already has a solver model.
|
|
This is determined by checking if the current tab has the SP_OBJ_CELL named range
|
|
which is associated with solver models.
|
|
Note that the named ranges are only created after SaveSolverSettings is called,
|
|
so before it is called, no solver-related named ranges exist.
|
|
*/
|
|
bool SolverSettings::TabHasSolverModel()
|
|
{
|
|
// Check if the named range for the objective value exists in the sheet
|
|
const auto iter = m_mNamedRanges.find(SP_OBJ_CELL);
|
|
if (iter == m_mNamedRanges.end())
|
|
return false;
|
|
OUString sRange = iter->second;
|
|
ScRangeData* pRangeData
|
|
= m_pRangeName->findByUpperName(ScGlobal::getCharClass().uppercase(sRange));
|
|
if (pRangeData)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
} // namespace sc
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
|