Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

10 files changed, 2066 insertions, 0 deletions

diff --git a/sccomp/source/solver/CoinMPSolver.cxx b/sccomp/source/solver/CoinMPSolver.cxx
new file mode 100644
index 0000000000..a6b423d2d4
--- /dev/null
+++ b/sccomp/source/solver/CoinMPSolver.cxx
@@ -0,0 +1,365 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you 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 .
+ */
+
+#include <CoinMP.h>
+#include <CoinError.hpp>
+
+#include "SolverComponent.hxx"
+#include <strings.hrc>
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/table/CellAddress.hpp>
+
+#include <rtl/math.hxx>
+#include <stdexcept>
+#include <vector>
+#include <float.h>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace com::sun::star;
+
+namespace {
+
+class CoinMPSolver : public SolverComponent
+{
+public:
+    CoinMPSolver() {}
+
+private:
+    virtual void SAL_CALL solve() override;
+    virtual OUString SAL_CALL getImplementationName() override
+    {
+        return "com.sun.star.comp.Calc.CoinMPSolver";
+    }
+    virtual OUString SAL_CALL getComponentDescription() override
+    {
+        return SolverComponent::GetResourceString( RID_COINMP_SOLVER_COMPONENT );
+    }
+};
+
+}
+
+void SAL_CALL CoinMPSolver::solve()
+{
+    uno::Reference<frame::XModel> xModel( mxDoc, uno::UNO_QUERY_THROW );
+
+    maStatus.clear();
+    mbSuccess = false;
+
+    xModel->lockControllers();
+
+    // collect variables in vector (?)
+
+    const auto & aVariableCells = maVariables;
+    size_t nVariables = aVariableCells.size();
+    size_t nVar = 0;
+
+    // collect all dependent cells
+
+    ScSolverCellHashMap aCellsHash;
+    aCellsHash[maObjective].reserve( nVariables + 1 );                  // objective function
+
+    for (const auto& rConstr : std::as_const(maConstraints))
+    {
+        table::CellAddress aCellAddr = rConstr.Left;
+        aCellsHash[aCellAddr].reserve( nVariables + 1 );                // constraints: left hand side
+
+        if ( rConstr.Right >>= aCellAddr )
+            aCellsHash[aCellAddr].reserve( nVariables + 1 );            // constraints: right hand side
+    }
+
+    // set all variables to zero
+    //! store old values?
+    //! use old values as initial values?
+    for ( const auto& rVarCell : aVariableCells )
+    {
+        SolverComponent::SetValue( mxDoc, rVarCell, 0.0 );
+    }
+
+    // read initial values from all dependent cells
+    for ( auto& rEntry : aCellsHash )
+    {
+        double fValue = SolverComponent::GetValue( mxDoc, rEntry.first );
+        rEntry.second.push_back( fValue );                         // store as first element, as-is
+    }
+
+    // loop through variables
+    for ( const auto& rVarCell : aVariableCells )
+    {
+        SolverComponent::SetValue( mxDoc, rVarCell, 1.0 );      // set to 1 to examine influence
+
+        // read value change from all dependent cells
+        for ( auto& rEntry : aCellsHash )
+        {
+            double fChanged = SolverComponent::GetValue( mxDoc, rEntry.first );
+            double fInitial = rEntry.second.front();
+            rEntry.second.push_back( fChanged - fInitial );
+        }
+
+        SolverComponent::SetValue( mxDoc, rVarCell, 2.0 );      // minimal test for linearity
+
+        for ( const auto& rEntry : aCellsHash )
+        {
+            double fInitial = rEntry.second.front();
+            double fCoeff   = rEntry.second.back();       // last appended: coefficient for this variable
+            double fTwo     = SolverComponent::GetValue( mxDoc, rEntry.first );
+
+            bool bLinear = rtl::math::approxEqual( fTwo, fInitial + 2.0 * fCoeff ) ||
+                           rtl::math::approxEqual( fInitial, fTwo - 2.0 * fCoeff );
+            // second comparison is needed in case fTwo is zero
+            if ( !bLinear )
+                maStatus = SolverComponent::GetResourceString( RID_ERROR_NONLINEAR );
+        }
+
+        SolverComponent::SetValue( mxDoc, rVarCell, 0.0 );      // set back to zero for examining next variable
+    }
+
+    xModel->unlockControllers();
+
+    if ( !maStatus.isEmpty() )
+        return;
+
+    //
+    // build parameter arrays for CoinMP
+    //
+
+    // set objective function
+
+    const std::vector<double>& rObjCoeff = aCellsHash[maObjective];
+    std::unique_ptr<double[]> pObjectCoeffs(new double[nVariables]);
+    for (nVar=0; nVar<nVariables; nVar++)
+        pObjectCoeffs[nVar] = rObjCoeff[nVar+1];
+    double nObjectConst = rObjCoeff[0];             // constant term of objective
+
+    // add rows
+
+    size_t nRows = maConstraints.getLength();
+    size_t nCompSize = nVariables * nRows;
+    std::unique_ptr<double[]> pCompMatrix(new double[nCompSize]);    // first collect all coefficients, row-wise
+    for (size_t i=0; i<nCompSize; i++)
+        pCompMatrix[i] = 0.0;
+
+    std::unique_ptr<double[]> pRHS(new double[nRows]);
+    std::unique_ptr<char[]> pRowType(new char[nRows]);
+    for (size_t i=0; i<nRows; i++)
+    {
+        pRHS[i] = 0.0;
+        pRowType[i] = 'N';
+    }
+
+    for (sal_Int32 nConstrPos = 0; nConstrPos < maConstraints.getLength(); ++nConstrPos)
+    {
+        // integer constraints are set later
+        sheet::SolverConstraintOperator eOp = maConstraints[nConstrPos].Operator;
+        if ( eOp == sheet::SolverConstraintOperator_LESS_EQUAL ||
+             eOp == sheet::SolverConstraintOperator_GREATER_EQUAL ||
+             eOp == sheet::SolverConstraintOperator_EQUAL )
+        {
+            double fDirectValue = 0.0;
+            bool bRightCell = false;
+            table::CellAddress aRightAddr;
+            const uno::Any& rRightAny = maConstraints[nConstrPos].Right;
+            if ( rRightAny >>= aRightAddr )
+                bRightCell = true;                  // cell specified as right-hand side
+            else
+                rRightAny >>= fDirectValue;         // constant value
+
+            table::CellAddress aLeftAddr = maConstraints[nConstrPos].Left;
+
+            const std::vector<double>& rLeftCoeff = aCellsHash[aLeftAddr];
+            double* pValues = &pCompMatrix[nConstrPos * nVariables];
+            for (nVar=0; nVar<nVariables; nVar++)
+                pValues[nVar] = rLeftCoeff[nVar+1];
+
+            // if left hand cell has a constant term, put into rhs value
+            double fRightValue = -rLeftCoeff[0];
+
+            if ( bRightCell )
+            {
+                const std::vector<double>& rRightCoeff = aCellsHash[aRightAddr];
+                // modify pValues with rhs coefficients
+                for (nVar=0; nVar<nVariables; nVar++)
+                    pValues[nVar] -= rRightCoeff[nVar+1];
+
+                fRightValue += rRightCoeff[0];      // constant term
+            }
+            else
+                fRightValue += fDirectValue;
+
+            switch ( eOp )
+            {
+                case sheet::SolverConstraintOperator_LESS_EQUAL:    pRowType[nConstrPos] = 'L'; break;
+                case sheet::SolverConstraintOperator_GREATER_EQUAL: pRowType[nConstrPos] = 'G'; break;
+                case sheet::SolverConstraintOperator_EQUAL:         pRowType[nConstrPos] = 'E'; break;
+                default:
+                    OSL_ENSURE( false, "unexpected enum type" );
+            }
+            pRHS[nConstrPos] = fRightValue;
+        }
+    }
+
+    // Find non-zero coefficients, column-wise
+
+    std::unique_ptr<int[]> pMatrixBegin(new int[nVariables+1]);
+    std::unique_ptr<int[]> pMatrixCount(new int[nVariables]);
+    std::unique_ptr<double[]> pMatrix(new double[nCompSize]);    // not always completely used
+    std::unique_ptr<int[]> pMatrixIndex(new int[nCompSize]);
+    int nMatrixPos = 0;
+    for (nVar=0; nVar<nVariables; nVar++)
+    {
+        int nBegin = nMatrixPos;
+        for (size_t nRow=0; nRow<nRows; nRow++)
+        {
+            double fCoeff = pCompMatrix[ nRow * nVariables + nVar ];    // row-wise
+            if ( fCoeff != 0.0 )
+            {
+                pMatrix[nMatrixPos] = fCoeff;
+                pMatrixIndex[nMatrixPos] = nRow;
+                ++nMatrixPos;
+            }
+        }
+        pMatrixBegin[nVar] = nBegin;
+        pMatrixCount[nVar] = nMatrixPos - nBegin;
+    }
+    pMatrixBegin[nVariables] = nMatrixPos;
+    pCompMatrix.reset();
+
+    // apply settings to all variables
+
+    std::unique_ptr<double[]> pLowerBounds(new double[nVariables]);
+    std::unique_ptr<double[]> pUpperBounds(new double[nVariables]);
+    for (nVar=0; nVar<nVariables; nVar++)
+    {
+        pLowerBounds[nVar] = mbNonNegative ? 0.0 : -DBL_MAX;
+        pUpperBounds[nVar] = DBL_MAX;
+
+        // bounds could possibly be further restricted from single-cell constraints
+    }
+
+    std::unique_ptr<char[]> pColType(new char[nVariables]);
+    for (nVar=0; nVar<nVariables; nVar++)
+        pColType[nVar] = mbInteger ? 'I' : 'C';
+
+    // apply single-var integer constraints
+
+    for (const auto& rConstr : std::as_const(maConstraints))
+    {
+        sheet::SolverConstraintOperator eOp = rConstr.Operator;
+        if ( eOp == sheet::SolverConstraintOperator_INTEGER ||
+             eOp == sheet::SolverConstraintOperator_BINARY )
+        {
+            table::CellAddress aLeftAddr = rConstr.Left;
+            // find variable index for cell
+            for (nVar=0; nVar<nVariables; nVar++)
+                if ( AddressEqual( aVariableCells[nVar], aLeftAddr ) )
+                {
+                    if ( eOp == sheet::SolverConstraintOperator_INTEGER )
+                        pColType[nVar] = 'I';
+                    else
+                    {
+                        pColType[nVar] = 'B';
+                        pLowerBounds[nVar] = 0.0;
+                        pUpperBounds[nVar] = 1.0;
+                    }
+                }
+        }
+    }
+
+    int nObjectSense = mbMaximize ? SOLV_OBJSENS_MAX : SOLV_OBJSENS_MIN;
+
+    HPROB hProb = CoinCreateProblem("");
+    int nResult = CoinLoadProblem( hProb, nVariables, nRows, nMatrixPos, 0,
+                    nObjectSense, nObjectConst, pObjectCoeffs.get(),
+                    pLowerBounds.get(), pUpperBounds.get(), pRowType.get(), pRHS.get(), nullptr,
+                    pMatrixBegin.get(), pMatrixCount.get(), pMatrixIndex.get(), pMatrix.get(),
+                    nullptr, nullptr, nullptr );
+    if (nResult == SOLV_CALL_SUCCESS)
+    {
+        nResult = CoinLoadInteger( hProb, pColType.get() );
+    }
+
+    pColType.reset();
+    pMatrixIndex.reset();
+    pMatrix.reset();
+    pMatrixCount.reset();
+    pMatrixBegin.reset();
+    pUpperBounds.reset();
+    pLowerBounds.reset();
+    pRowType.reset();
+    pRHS.reset();
+    pObjectCoeffs.reset();
+
+    CoinSetRealOption( hProb, COIN_REAL_MAXSECONDS, mnTimeout );
+    CoinSetRealOption( hProb, COIN_REAL_MIPMAXSEC, mnTimeout );
+
+    // TODO: handle (or remove) settings: epsilon, B&B depth
+
+    // solve model
+
+    if (nResult == SOLV_CALL_SUCCESS)
+    {
+        nResult = CoinCheckProblem( hProb );
+    }
+
+    if (nResult == SOLV_CALL_SUCCESS)
+    {
+        try
+        {
+            nResult = CoinOptimizeProblem( hProb, 0 );
+        }
+        catch (const CoinError& e)
+        {
+            CoinUnloadProblem(hProb);
+            throw std::runtime_error(e.message());
+        }
+    }
+
+    mbSuccess = ( nResult == SOLV_CALL_SUCCESS );
+    if ( mbSuccess )
+    {
+        // get solution
+
+        maSolution.realloc( nVariables );
+        CoinGetSolutionValues( hProb, maSolution.getArray(), nullptr, nullptr, nullptr );
+        mfResultValue = CoinGetObjectValue( hProb );
+    }
+    else
+    {
+        int nSolutionStatus = CoinGetSolutionStatus( hProb );
+        if ( nSolutionStatus == 1 )
+            maStatus = SolverComponent::GetResourceString( RID_ERROR_INFEASIBLE );
+        else if ( nSolutionStatus == 2 )
+            maStatus = SolverComponent::GetResourceString( RID_ERROR_UNBOUNDED );
+        // TODO: detect timeout condition and report as RID_ERROR_TIMEOUT
+        // (currently reported as infeasible)
+    }
+
+    CoinUnloadProblem( hProb );
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_Calc_CoinMPSolver_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new CoinMPSolver());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sccomp/source/solver/DifferentialEvolution.hxx b/sccomp/source/solver/DifferentialEvolution.hxx
new file mode 100644
index 0000000000..97453437cd
--- /dev/null
+++ b/sccomp/source/solver/DifferentialEvolution.hxx
@@ -0,0 +1,162 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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/.
+ *
+ */
+
+#pragma once
+
+#include <vector>
+#include <random>
+#include <limits>
+
+struct Individual
+{
+    std::vector<double> mVariables;
+};
+
+template <typename DataProvider> class DifferentialEvolutionAlgorithm
+{
+    static constexpr double mnDifferentialWeight = 0.5; // [0, 2]
+    static constexpr double mnCrossoverProbability = 0.9; // [0, 1]
+
+    static constexpr double constAcceptedPrecision = 0.000000001;
+
+    DataProvider& mrDataProvider;
+
+    size_t mnPopulationSize;
+    std::vector<Individual> maPopulation;
+
+    std::random_device maRandomDevice;
+    std::mt19937 maGenerator;
+    size_t mnDimensionality;
+
+    std::uniform_int_distribution<> maRandomPopulation;
+    std::uniform_int_distribution<> maRandomDimensionality;
+    std::uniform_real_distribution<> maRandom01;
+
+    Individual maBestCandidate;
+    double mfBestFitness;
+    int mnGeneration;
+    int mnLastChange;
+
+public:
+    DifferentialEvolutionAlgorithm(DataProvider& rDataProvider, size_t nPopulationSize)
+        : mrDataProvider(rDataProvider)
+        , mnPopulationSize(nPopulationSize)
+        , maGenerator(maRandomDevice())
+        , mnDimensionality(mrDataProvider.getDimensionality())
+        , maRandomPopulation(0, mnPopulationSize - 1)
+        , maRandomDimensionality(0, mnDimensionality - 1)
+        , maRandom01(0.0, 1.0)
+        , mfBestFitness(std::numeric_limits<double>::lowest())
+        , mnGeneration(0)
+        , mnLastChange(0)
+    {
+    }
+
+    std::vector<double> const& getResult() { return maBestCandidate.mVariables; }
+
+    int getGeneration() { return mnGeneration; }
+
+    int getLastChange() { return mnLastChange; }
+
+    void initialize()
+    {
+        mnGeneration = 0;
+        mnLastChange = 0;
+        maPopulation.clear();
+        maBestCandidate.mVariables.clear();
+
+        // Initialize population with individuals that have been initialized with uniform random
+        // noise
+        // uniform noise means random value inside your search space
+        maPopulation.reserve(mnPopulationSize);
+        for (size_t i = 0; i < mnPopulationSize; ++i)
+        {
+            maPopulation.emplace_back();
+            Individual& rIndividual = maPopulation.back();
+            mrDataProvider.initializeVariables(rIndividual.mVariables, maGenerator);
+        }
+    }
+
+    // Calculate one generation
+    bool next()
+    {
+        bool bBestChanged = false;
+
+        for (size_t agentIndex = 0; agentIndex < mnPopulationSize; ++agentIndex)
+        {
+            // calculate new candidate solution
+
+            // pick random point from population
+            size_t x = agentIndex; // randomPopulation(generator);
+            size_t a, b, c;
+
+            // create a copy of chosen random agent in population
+            Individual& rOriginal = maPopulation[x];
+            Individual aCandidate(rOriginal);
+
+            // pick three different random points from population
+            do
+            {
+                a = maRandomPopulation(maGenerator);
+            } while (a == x);
+
+            do
+            {
+                b = maRandomPopulation(maGenerator);
+            } while (b == x || b == a);
+
+            do
+            {
+                c = maRandomPopulation(maGenerator);
+
+            } while (c == x || c == a || c == b);
+
+            size_t randomIndex = maRandomDimensionality(maGenerator);
+
+            for (size_t index = 0; index < mnDimensionality; ++index)
+            {
+                double randomCrossoverProbability = maRandom01(maGenerator);
+                if (index == randomIndex || randomCrossoverProbability < mnCrossoverProbability)
+                {
+                    double fVarA = maPopulation[a].mVariables[index];
+                    double fVarB = maPopulation[b].mVariables[index];
+                    double fVarC = maPopulation[c].mVariables[index];
+
+                    double fNewValue = fVarA + mnDifferentialWeight * (fVarB - fVarC);
+                    fNewValue = mrDataProvider.boundVariable(index, fNewValue);
+                    aCandidate.mVariables[index] = fNewValue;
+                }
+            }
+
+            double fCandidateFitness = mrDataProvider.calculateFitness(aCandidate.mVariables);
+
+            // see if is better than original, if so replace
+            if (fCandidateFitness > mrDataProvider.calculateFitness(rOriginal.mVariables))
+            {
+                maPopulation[x] = aCandidate;
+
+                if (fCandidateFitness > mfBestFitness)
+                {
+                    if (std::abs(fCandidateFitness - mfBestFitness) > constAcceptedPrecision)
+                    {
+                        bBestChanged = true;
+                        mnLastChange = mnGeneration;
+                    }
+                    mfBestFitness = fCandidateFitness;
+                    maBestCandidate = maPopulation[x];
+                }
+            }
+        }
+        mnGeneration++;
+        return bBestChanged;
+    }
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sccomp/source/solver/LpsolveSolver.cxx b/sccomp/source/solver/LpsolveSolver.cxx
new file mode 100644
index 0000000000..78cd25e811
--- /dev/null
+++ b/sccomp/source/solver/LpsolveSolver.cxx
@@ -0,0 +1,334 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you 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 .
+ *
+ ************************************************************************/
+
+#include <sal/config.h>
+
+#undef LANGUAGE_NONE
+#if defined _WIN32
+#define WINAPI __stdcall
+#endif
+#define LoadInverseLib FALSE
+#define LoadLanguageLib FALSE
+#ifdef SYSTEM_LPSOLVE
+#include <lpsolve/lp_lib.h>
+#else
+#include <lp_lib.h>
+#endif
+#undef LANGUAGE_NONE
+
+#include "SolverComponent.hxx"
+#include <strings.hrc>
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/table/CellAddress.hpp>
+#include <rtl/math.hxx>
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+namespace com::sun::star::uno { class XComponentContext; }
+
+using namespace com::sun::star;
+
+namespace {
+
+class LpsolveSolver : public SolverComponent
+{
+public:
+    LpsolveSolver() {}
+
+private:
+    virtual void SAL_CALL solve() override;
+    virtual OUString SAL_CALL getImplementationName() override
+    {
+        return "com.sun.star.comp.Calc.LpsolveSolver";
+    }
+    virtual OUString SAL_CALL getComponentDescription() override
+    {
+        return SolverComponent::GetResourceString( RID_SOLVER_COMPONENT );
+    }
+};
+
+}
+
+void SAL_CALL LpsolveSolver::solve()
+{
+    uno::Reference<frame::XModel> xModel( mxDoc, uno::UNO_QUERY_THROW );
+
+    maStatus.clear();
+    mbSuccess = false;
+
+    if ( mnEpsilonLevel < EPS_TIGHT || mnEpsilonLevel > EPS_BAGGY )
+    {
+        maStatus = SolverComponent::GetResourceString( RID_ERROR_EPSILONLEVEL );
+        return;
+    }
+
+    xModel->lockControllers();
+
+    // collect variables in vector (?)
+
+    const auto & aVariableCells = maVariables;
+    size_t nVariables = aVariableCells.size();
+    size_t nVar = 0;
+
+    // collect all dependent cells
+
+    ScSolverCellHashMap aCellsHash;
+    aCellsHash[maObjective].reserve( nVariables + 1 );                  // objective function
+
+    for (const auto& rConstr : std::as_const(maConstraints))
+    {
+        table::CellAddress aCellAddr = rConstr.Left;
+        aCellsHash[aCellAddr].reserve( nVariables + 1 );                // constraints: left hand side
+
+        if ( rConstr.Right >>= aCellAddr )
+            aCellsHash[aCellAddr].reserve( nVariables + 1 );            // constraints: right hand side
+    }
+
+    // set all variables to zero
+    //! store old values?
+    //! use old values as initial values?
+    for ( const auto& rVarCell : aVariableCells )
+    {
+        SolverComponent::SetValue( mxDoc, rVarCell, 0.0 );
+    }
+
+    // read initial values from all dependent cells
+    for ( auto& rEntry : aCellsHash )
+    {
+        double fValue = SolverComponent::GetValue( mxDoc, rEntry.first );
+        rEntry.second.push_back( fValue );                         // store as first element, as-is
+    }
+
+    // loop through variables
+    for ( const auto& rVarCell : aVariableCells )
+    {
+        SolverComponent::SetValue( mxDoc, rVarCell, 1.0 );      // set to 1 to examine influence
+
+        // read value change from all dependent cells
+        for ( auto& rEntry : aCellsHash )
+        {
+            double fChanged = SolverComponent::GetValue( mxDoc, rEntry.first );
+            double fInitial = rEntry.second.front();
+            rEntry.second.push_back( fChanged - fInitial );
+        }
+
+        SolverComponent::SetValue( mxDoc, rVarCell, 2.0 );      // minimal test for linearity
+
+        for ( const auto& rEntry : aCellsHash )
+        {
+            double fInitial = rEntry.second.front();
+            double fCoeff   = rEntry.second.back();       // last appended: coefficient for this variable
+            double fTwo     = SolverComponent::GetValue( mxDoc, rEntry.first );
+
+            bool bLinear = rtl::math::approxEqual( fTwo, fInitial + 2.0 * fCoeff ) ||
+                           rtl::math::approxEqual( fInitial, fTwo - 2.0 * fCoeff );
+            // second comparison is needed in case fTwo is zero
+            if ( !bLinear )
+                maStatus = SolverComponent::GetResourceString( RID_ERROR_NONLINEAR );
+        }
+
+        SolverComponent::SetValue( mxDoc, rVarCell, 0.0 );      // set back to zero for examining next variable
+    }
+
+    xModel->unlockControllers();
+
+    if ( !maStatus.isEmpty() )
+        return;
+
+
+    // build lp_solve model
+
+
+    lprec* lp = make_lp( 0, nVariables );
+    if ( !lp )
+        return;
+
+    set_outputfile( lp, const_cast<char*>( "" ) );  // no output
+
+    // set objective function
+
+    const std::vector<double>& rObjCoeff = aCellsHash[maObjective];
+    std::unique_ptr<REAL[]> pObjVal(new REAL[nVariables+1]);
+    pObjVal[0] = 0.0;                           // ignored
+    for (nVar=0; nVar<nVariables; nVar++)
+        pObjVal[nVar+1] = rObjCoeff[nVar+1];
+    set_obj_fn( lp, pObjVal.get() );
+    pObjVal.reset();
+    set_rh( lp, 0, rObjCoeff[0] );              // constant term of objective
+
+    // add rows
+
+    set_add_rowmode(lp, TRUE);
+
+    for (const auto& rConstr : std::as_const(maConstraints))
+    {
+        // integer constraints are set later
+        sheet::SolverConstraintOperator eOp = rConstr.Operator;
+        if ( eOp == sheet::SolverConstraintOperator_LESS_EQUAL ||
+             eOp == sheet::SolverConstraintOperator_GREATER_EQUAL ||
+             eOp == sheet::SolverConstraintOperator_EQUAL )
+        {
+            double fDirectValue = 0.0;
+            bool bRightCell = false;
+            table::CellAddress aRightAddr;
+            const uno::Any& rRightAny = rConstr.Right;
+            if ( rRightAny >>= aRightAddr )
+                bRightCell = true;                  // cell specified as right-hand side
+            else
+                rRightAny >>= fDirectValue;         // constant value
+
+            table::CellAddress aLeftAddr = rConstr.Left;
+
+            const std::vector<double>& rLeftCoeff = aCellsHash[aLeftAddr];
+            std::unique_ptr<REAL[]> pValues(new REAL[nVariables+1] );
+            pValues[0] = 0.0;                               // ignored?
+            for (nVar=0; nVar<nVariables; nVar++)
+                pValues[nVar+1] = rLeftCoeff[nVar+1];
+
+            // if left hand cell has a constant term, put into rhs value
+            double fRightValue = -rLeftCoeff[0];
+
+            if ( bRightCell )
+            {
+                const std::vector<double>& rRightCoeff = aCellsHash[aRightAddr];
+                // modify pValues with rhs coefficients
+                for (nVar=0; nVar<nVariables; nVar++)
+                    pValues[nVar+1] -= rRightCoeff[nVar+1];
+
+                fRightValue += rRightCoeff[0];      // constant term
+            }
+            else
+                fRightValue += fDirectValue;
+
+            int nConstrType = LE;
+            switch ( eOp )
+            {
+                case sheet::SolverConstraintOperator_LESS_EQUAL:    nConstrType = LE; break;
+                case sheet::SolverConstraintOperator_GREATER_EQUAL: nConstrType = GE; break;
+                case sheet::SolverConstraintOperator_EQUAL:         nConstrType = EQ; break;
+                default:
+                    OSL_FAIL( "unexpected enum type" );
+            }
+            add_constraint( lp, pValues.get(), nConstrType, fRightValue );
+        }
+    }
+
+    set_add_rowmode(lp, FALSE);
+
+    // apply settings to all variables
+
+    for (nVar=0; nVar<nVariables; nVar++)
+    {
+        if ( !mbNonNegative )
+            set_unbounded(lp, nVar+1);          // allow negative (default is non-negative)
+                                                //! collect bounds from constraints?
+        if ( mbInteger )
+            set_int(lp, nVar+1, TRUE);
+    }
+
+    // apply single-var integer constraints
+
+    for (const auto& rConstr : std::as_const(maConstraints))
+    {
+        sheet::SolverConstraintOperator eOp = rConstr.Operator;
+        if ( eOp == sheet::SolverConstraintOperator_INTEGER ||
+             eOp == sheet::SolverConstraintOperator_BINARY )
+        {
+            table::CellAddress aLeftAddr = rConstr.Left;
+            // find variable index for cell
+            for (nVar=0; nVar<nVariables; nVar++)
+                if ( AddressEqual( aVariableCells[nVar], aLeftAddr ) )
+                {
+                    if ( eOp == sheet::SolverConstraintOperator_INTEGER )
+                        set_int(lp, nVar+1, TRUE);
+                    else
+                        set_binary(lp, nVar+1, TRUE);
+                }
+        }
+    }
+
+    if ( mbMaximize )
+        set_maxim(lp);
+    else
+        set_minim(lp);
+
+    if ( !mbLimitBBDepth )
+        set_bb_depthlimit( lp, 0 );
+
+    set_epslevel( lp, mnEpsilonLevel );
+    set_timeout( lp, mnTimeout );
+
+    // solve model
+
+    int nResult = ::solve( lp );
+
+    mbSuccess = ( nResult == OPTIMAL );
+    if ( mbSuccess )
+    {
+        // get solution
+
+        maSolution.realloc( nVariables );
+
+        REAL* pResultVar = nullptr;
+        get_ptr_variables( lp, &pResultVar );
+        std::copy_n(pResultVar, nVariables, maSolution.getArray());
+
+        mfResultValue = get_objective( lp );
+    }
+    else if ( nResult == INFEASIBLE )
+        maStatus = SolverComponent::GetResourceString( RID_ERROR_INFEASIBLE );
+    else if ( nResult == UNBOUNDED )
+        maStatus = SolverComponent::GetResourceString( RID_ERROR_UNBOUNDED );
+    else if ( nResult == TIMEOUT || nResult == SUBOPTIMAL )
+        maStatus = SolverComponent::GetResourceString( RID_ERROR_TIMEOUT );
+    // SUBOPTIMAL is assumed to be caused by a timeout, and reported as an error
+
+    delete_lp( lp );
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
+com_sun_star_comp_Calc_LpsolveSolver_get_implementation(
+    css::uno::XComponentContext *,
+    css::uno::Sequence<css::uno::Any> const &)
+{
+    return cppu::acquire(new LpsolveSolver());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sccomp/source/solver/ParticelSwarmOptimization.hxx b/sccomp/source/solver/ParticelSwarmOptimization.hxx
new file mode 100644
index 0000000000..ad11033093
--- /dev/null
+++ b/sccomp/source/solver/ParticelSwarmOptimization.hxx
@@ -0,0 +1,177 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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/.
+ *
+ */
+
+#pragma once
+
+#include <vector>
+#include <random>
+#include <limits>
+
+struct Particle
+{
+    Particle(size_t nDimensionality)
+        : mVelocity(nDimensionality)
+        , mPosition(nDimensionality)
+        , mCurrentFitness(std::numeric_limits<float>::lowest())
+        , mBestPosition(nDimensionality)
+        , mBestFitness(std::numeric_limits<float>::lowest())
+    {
+    }
+
+    std::vector<double> mVelocity;
+
+    std::vector<double> mPosition;
+    double mCurrentFitness;
+
+    std::vector<double> mBestPosition;
+    double mBestFitness;
+};
+
+template <typename DataProvider> class ParticleSwarmOptimizationAlgorithm
+{
+private:
+    // inertia
+    static constexpr double constWeight = 0.729;
+    // cognitive coefficient
+    static constexpr double c1 = 1.49445;
+    // social  coefficient
+    static constexpr double c2 = 1.49445;
+
+    static constexpr double constAcceptedPrecision = 0.000000001;
+
+    DataProvider& mrDataProvider;
+
+    size_t mnNumOfParticles;
+
+    std::vector<Particle> maSwarm;
+
+    std::random_device maRandomDevice;
+    std::mt19937 maGenerator;
+    size_t mnDimensionality;
+
+    std::uniform_real_distribution<> maRandom01;
+
+    std::vector<double> maBestPosition;
+    double mfBestFitness;
+    int mnGeneration;
+    int mnLastChange;
+
+public:
+    ParticleSwarmOptimizationAlgorithm(DataProvider& rDataProvider, size_t nNumOfParticles)
+        : mrDataProvider(rDataProvider)
+        , mnNumOfParticles(nNumOfParticles)
+        , maGenerator(maRandomDevice())
+        , mnDimensionality(mrDataProvider.getDimensionality())
+        , maRandom01(0.0, 1.0)
+        , maBestPosition(mnDimensionality)
+        , mfBestFitness(std::numeric_limits<float>::lowest())
+        , mnGeneration(0)
+        , mnLastChange(0)
+    {
+    }
+
+    std::vector<double> const& getResult() { return maBestPosition; }
+
+    int getGeneration() { return mnGeneration; }
+
+    int getLastChange() { return mnLastChange; }
+
+    void initialize()
+    {
+        mnGeneration = 0;
+        mnLastChange = 0;
+        maSwarm.clear();
+
+        mfBestFitness = std::numeric_limits<float>::lowest();
+
+        maSwarm.reserve(mnNumOfParticles);
+        for (size_t i = 0; i < mnNumOfParticles; i++)
+        {
+            maSwarm.emplace_back(mnDimensionality);
+            Particle& rParticle = maSwarm.back();
+
+            mrDataProvider.initializeVariables(rParticle.mPosition, maGenerator);
+            mrDataProvider.initializeVariables(rParticle.mVelocity, maGenerator);
+
+            for (size_t k = 0; k < mnDimensionality; k++)
+            {
+                rParticle.mPosition[k] = mrDataProvider.clampVariable(k, rParticle.mPosition[k]);
+            }
+
+            rParticle.mCurrentFitness = mrDataProvider.calculateFitness(rParticle.mPosition);
+
+            for (size_t k = 0; k < mnDimensionality; k++)
+            {
+                rParticle.mPosition[k] = mrDataProvider.clampVariable(k, rParticle.mPosition[k]);
+            }
+
+            rParticle.mBestPosition.insert(rParticle.mBestPosition.begin(),
+                                           rParticle.mPosition.begin(), rParticle.mPosition.end());
+            rParticle.mBestFitness = rParticle.mCurrentFitness;
+
+            if (rParticle.mCurrentFitness > mfBestFitness)
+            {
+                mfBestFitness = rParticle.mCurrentFitness;
+                maBestPosition.insert(maBestPosition.begin(), rParticle.mPosition.begin(),
+                                      rParticle.mPosition.end());
+            }
+        }
+    }
+
+    bool next()
+    {
+        bool bBestChanged = false;
+
+        for (Particle& rParticle : maSwarm)
+        {
+            double fRandom1 = maRandom01(maGenerator);
+            double fRandom2 = maRandom01(maGenerator);
+
+            for (size_t k = 0; k < mnDimensionality; k++)
+            {
+                rParticle.mVelocity[k]
+                    = (constWeight * rParticle.mVelocity[k])
+                      + (c1 * fRandom1 * (rParticle.mBestPosition[k] - rParticle.mPosition[k]))
+                      + (c2 * fRandom2 * (maBestPosition[k] - rParticle.mPosition[k]));
+
+                mrDataProvider.clampVariable(k, rParticle.mVelocity[k]);
+
+                rParticle.mPosition[k] += rParticle.mVelocity[k];
+                rParticle.mPosition[k] = mrDataProvider.clampVariable(k, rParticle.mPosition[k]);
+            }
+
+            rParticle.mCurrentFitness = mrDataProvider.calculateFitness(rParticle.mPosition);
+
+            if (rParticle.mCurrentFitness > rParticle.mBestFitness)
+            {
+                rParticle.mBestFitness = rParticle.mCurrentFitness;
+                rParticle.mBestPosition.insert(rParticle.mBestPosition.begin(),
+                                               rParticle.mPosition.begin(),
+                                               rParticle.mPosition.end());
+            }
+
+            if (rParticle.mCurrentFitness > mfBestFitness)
+            {
+                if (std::abs(rParticle.mCurrentFitness - mfBestFitness) > constAcceptedPrecision)
+                {
+                    bBestChanged = true;
+                    mnLastChange = mnGeneration;
+                }
+                maBestPosition.insert(maBestPosition.begin(), rParticle.mPosition.begin(),
+                                      rParticle.mPosition.end());
+                mfBestFitness = rParticle.mCurrentFitness;
+            }
+        }
+        mnGeneration++;
+        return bBestChanged;
+    }
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sccomp/source/solver/SolverComponent.cxx b/sccomp/source/solver/SolverComponent.cxx
new file mode 100644
index 0000000000..e31a840733
--- /dev/null
+++ b/sccomp/source/solver/SolverComponent.cxx
@@ -0,0 +1,254 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you 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 .
+ */
+
+#include "SolverComponent.hxx"
+#include <strings.hrc>
+
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
+#include <com/sun/star/sheet/XSpreadsheet.hpp>
+#include <com/sun/star/table/CellAddress.hpp>
+
+#include <cppuhelper/supportsservice.hxx>
+
+#include <unotools/resmgr.hxx>
+
+using namespace com::sun::star;
+
+
+constexpr OUStringLiteral STR_NONNEGATIVE = u"NonNegative";
+constexpr OUStringLiteral STR_INTEGER = u"Integer";
+constexpr OUStringLiteral STR_TIMEOUT = u"Timeout";
+constexpr OUStringLiteral STR_EPSILONLEVEL = u"EpsilonLevel";
+constexpr OUStringLiteral STR_LIMITBBDEPTH = u"LimitBBDepth";
+
+
+//  Resources from tools are used for translated strings
+
+OUString SolverComponent::GetResourceString(TranslateId aId)
+{
+    return Translate::get(aId, Translate::Create("scc"));
+}
+
+size_t ScSolverCellHash::operator()( const css::table::CellAddress& rAddress ) const
+{
+    return ( rAddress.Sheet << 24 ) | ( rAddress.Column << 16 ) | rAddress.Row;
+}
+
+bool ScSolverCellEqual::operator()( const css::table::CellAddress& rAddr1, const css::table::CellAddress& rAddr2 ) const
+{
+    return AddressEqual( rAddr1, rAddr2 );
+}
+
+namespace
+{
+    enum
+    {
+        PROP_NONNEGATIVE,
+        PROP_INTEGER,
+        PROP_TIMEOUT,
+        PROP_EPSILONLEVEL,
+        PROP_LIMITBBDEPTH
+    };
+}
+
+uno::Reference<table::XCell> SolverComponent::GetCell( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
+                                          const table::CellAddress& rPos )
+{
+    uno::Reference<container::XIndexAccess> xSheets( xDoc->getSheets(), uno::UNO_QUERY );
+    uno::Reference<sheet::XSpreadsheet> xSheet( xSheets->getByIndex( rPos.Sheet ), uno::UNO_QUERY );
+    return xSheet->getCellByPosition( rPos.Column, rPos.Row );
+}
+
+void SolverComponent::SetValue( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
+                   const table::CellAddress& rPos, double fValue )
+{
+    SolverComponent::GetCell( xDoc, rPos )->setValue( fValue );
+}
+
+double SolverComponent::GetValue( const uno::Reference<sheet::XSpreadsheetDocument>& xDoc,
+                     const table::CellAddress& rPos )
+{
+    return SolverComponent::GetCell( xDoc, rPos )->getValue();
+}
+
+SolverComponent::SolverComponent() :
+    OPropertyContainer( GetBroadcastHelper() ),
+    mbMaximize( true ),
+    mbNonNegative( false ),
+    mbInteger( false ),
+    mnTimeout( 100 ),
+    mnEpsilonLevel( 0 ),
+    mbLimitBBDepth( true ),
+    mbSuccess( false ),
+    mfResultValue( 0.0 )
+{
+    // for XPropertySet implementation:
+    registerProperty( STR_NONNEGATIVE,  PROP_NONNEGATIVE,  0, &mbNonNegative,  cppu::UnoType<decltype(mbNonNegative)>::get()  );
+    registerProperty( STR_INTEGER,      PROP_INTEGER,      0, &mbInteger,      cppu::UnoType<decltype(mbInteger)>::get()      );
+    registerProperty( STR_TIMEOUT,      PROP_TIMEOUT,      0, &mnTimeout,      cppu::UnoType<decltype(mnTimeout)>::get()      );
+    registerProperty( STR_EPSILONLEVEL, PROP_EPSILONLEVEL, 0, &mnEpsilonLevel, cppu::UnoType<decltype(mnEpsilonLevel)>::get() );
+    registerProperty( STR_LIMITBBDEPTH, PROP_LIMITBBDEPTH, 0, &mbLimitBBDepth, cppu::UnoType<decltype(mbLimitBBDepth)>::get() );
+}
+
+SolverComponent::~SolverComponent()
+{
+}
+
+IMPLEMENT_FORWARD_XINTERFACE2( SolverComponent, SolverComponent_Base, OPropertyContainer )
+IMPLEMENT_FORWARD_XTYPEPROVIDER2( SolverComponent, SolverComponent_Base, OPropertyContainer )
+
+cppu::IPropertyArrayHelper* SolverComponent::createArrayHelper() const
+{
+    uno::Sequence<beans::Property> aProps;
+    describeProperties( aProps );
+    return new cppu::OPropertyArrayHelper( aProps );
+}
+
+cppu::IPropertyArrayHelper& SAL_CALL SolverComponent::getInfoHelper()
+{
+    return *getArrayHelper();
+}
+
+uno::Reference<beans::XPropertySetInfo> SAL_CALL SolverComponent::getPropertySetInfo()
+{
+    return createPropertySetInfo( getInfoHelper() );
+}
+
+// XSolverDescription
+
+OUString SAL_CALL SolverComponent::getStatusDescription()
+{
+    return maStatus;
+}
+
+OUString SAL_CALL SolverComponent::getPropertyDescription( const OUString& rPropertyName )
+{
+    TranslateId pResId;
+    sal_Int32 nHandle = getInfoHelper().getHandleByName( rPropertyName );
+    switch (nHandle)
+    {
+        case PROP_NONNEGATIVE:
+            pResId = RID_PROPERTY_NONNEGATIVE;
+            break;
+        case PROP_INTEGER:
+            pResId = RID_PROPERTY_INTEGER;
+            break;
+        case PROP_TIMEOUT:
+            pResId = RID_PROPERTY_TIMEOUT;
+            break;
+        case PROP_EPSILONLEVEL:
+            pResId = RID_PROPERTY_EPSILONLEVEL;
+            break;
+        case PROP_LIMITBBDEPTH:
+            pResId = RID_PROPERTY_LIMITBBDEPTH;
+            break;
+        default:
+            {
+                // unknown - leave empty
+            }
+    }
+    OUString aRet;
+    if (pResId)
+        aRet = SolverComponent::GetResourceString(pResId);
+    return aRet;
+}
+
+// XSolver: settings
+
+uno::Reference<sheet::XSpreadsheetDocument> SAL_CALL SolverComponent::getDocument()
+{
+    return mxDoc;
+}
+
+void SAL_CALL SolverComponent::setDocument( const uno::Reference<sheet::XSpreadsheetDocument>& _document )
+{
+    mxDoc = _document;
+}
+
+table::CellAddress SAL_CALL SolverComponent::getObjective()
+{
+    return maObjective;
+}
+
+void SAL_CALL SolverComponent::setObjective( const table::CellAddress& _objective )
+{
+    maObjective = _objective;
+}
+
+uno::Sequence<table::CellAddress> SAL_CALL SolverComponent::getVariables()
+{
+    return maVariables;
+}
+
+void SAL_CALL SolverComponent::setVariables( const uno::Sequence<table::CellAddress>& _variables )
+{
+    maVariables = _variables;
+}
+
+uno::Sequence<sheet::SolverConstraint> SAL_CALL SolverComponent::getConstraints()
+{
+    return maConstraints;
+}
+
+void SAL_CALL SolverComponent::setConstraints( const uno::Sequence<sheet::SolverConstraint>& _constraints )
+{
+    maConstraints = _constraints;
+}
+
+sal_Bool SAL_CALL SolverComponent::getMaximize()
+{
+    return mbMaximize;
+}
+
+void SAL_CALL SolverComponent::setMaximize( sal_Bool _maximize )
+{
+    mbMaximize = _maximize;
+}
+
+// XSolver: get results
+
+sal_Bool SAL_CALL SolverComponent::getSuccess()
+{
+    return mbSuccess;
+}
+
+double SAL_CALL SolverComponent::getResultValue()
+{
+    return mfResultValue;
+}
+
+uno::Sequence<double> SAL_CALL SolverComponent::getSolution()
+{
+    return maSolution;
+}
+
+// XServiceInfo
+
+sal_Bool SAL_CALL SolverComponent::supportsService( const OUString& rServiceName )
+{
+    return cppu::supportsService(this, rServiceName);
+}
+
+uno::Sequence<OUString> SAL_CALL SolverComponent::getSupportedServiceNames()
+{
+    return { "com.sun.star.sheet.Solver" };
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sccomp/source/solver/SolverComponent.hxx b/sccomp/source/solver/SolverComponent.hxx
new file mode 100644
index 0000000000..4e10c038a4
--- /dev/null
+++ b/sccomp/source/solver/SolverComponent.hxx
@@ -0,0 +1,140 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you 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 .
+ */
+
+#pragma once
+
+#include <com/sun/star/sheet/XSolver.hpp>
+#include <com/sun/star/sheet/XSolverDescription.hpp>
+#include <com/sun/star/table/CellAddress.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <cppuhelper/implbase.hxx>
+#include <comphelper/broadcasthelper.hxx>
+#include <comphelper/propertycontainer.hxx>
+#include <comphelper/proparrhlp.hxx>
+#include <unotools/resmgr.hxx>
+
+#include <unordered_map>
+
+namespace com::sun::star::table { class XCell; }
+
+// hash map for the coefficients of a dependent cell (objective or constraint)
+// The size of each vector is the number of columns (variable cells) plus one, first entry is initial value.
+
+struct ScSolverCellHash
+{
+    size_t operator()( const css::table::CellAddress& rAddress ) const;
+};
+
+inline bool AddressEqual( const css::table::CellAddress& rAddr1, const css::table::CellAddress& rAddr2 )
+{
+    return rAddr1.Sheet == rAddr2.Sheet && rAddr1.Column == rAddr2.Column && rAddr1.Row == rAddr2.Row;
+}
+
+struct ScSolverCellEqual
+{
+    bool operator()( const css::table::CellAddress& rAddr1, const css::table::CellAddress& rAddr2 ) const;
+};
+
+typedef std::unordered_map< css::table::CellAddress, std::vector<double>, ScSolverCellHash, ScSolverCellEqual > ScSolverCellHashMap;
+
+typedef cppu::WeakImplHelper<
+                css::sheet::XSolver,
+                css::sheet::XSolverDescription,
+                css::lang::XServiceInfo >
+        SolverComponent_Base;
+
+class SolverComponent : public comphelper::OMutexAndBroadcastHelper,
+                        public comphelper::OPropertyContainer,
+                        public comphelper::OPropertyArrayUsageHelper< SolverComponent >,
+                        public SolverComponent_Base
+{
+protected:
+    // settings
+    css::uno::Reference< css::sheet::XSpreadsheetDocument > mxDoc;
+    css::table::CellAddress                                 maObjective;
+    css::uno::Sequence< css::table::CellAddress >           maVariables;
+    css::uno::Sequence< css::sheet::SolverConstraint >      maConstraints;
+    bool                                                    mbMaximize;
+    // set via XPropertySet
+    bool                                                    mbNonNegative;
+    bool                                                    mbInteger;
+    sal_Int32                                               mnTimeout;
+    sal_Int32                                               mnEpsilonLevel;
+    bool                                                    mbLimitBBDepth;
+    // results
+    bool                                                    mbSuccess;
+    double                                                  mfResultValue;
+    css::uno::Sequence< double >                            maSolution;
+    OUString                                                maStatus;
+
+    static OUString GetResourceString(TranslateId aId);
+    static css::uno::Reference<css::table::XCell> GetCell(
+            const css::uno::Reference<css::sheet::XSpreadsheetDocument>& xDoc,
+            const css::table::CellAddress& rPos );
+    static void SetValue(
+            const css::uno::Reference<css::sheet::XSpreadsheetDocument>& xDoc,
+            const css::table::CellAddress& rPos, double fValue );
+    static double GetValue(
+            const css::uno::Reference<css::sheet::XSpreadsheetDocument>& xDoc,
+            const css::table::CellAddress& rPos );
+
+public:
+                            SolverComponent();
+    virtual                 ~SolverComponent() override;
+
+    DECLARE_XINTERFACE()
+    DECLARE_XTYPEPROVIDER()
+
+    virtual css::uno::Reference< css::beans::XPropertySetInfo > SAL_CALL getPropertySetInfo() override;
+    virtual ::cppu::IPropertyArrayHelper& SAL_CALL getInfoHelper() override;     // from OPropertySetHelper
+    virtual ::cppu::IPropertyArrayHelper* createArrayHelper() const override;    // from OPropertyArrayUsageHelper
+
+                            // XSolver
+    virtual css::uno::Reference< css::sheet::XSpreadsheetDocument > SAL_CALL getDocument() override;
+    virtual void SAL_CALL   setDocument( const css::uno::Reference<
+                                    css::sheet::XSpreadsheetDocument >& _document ) override;
+    virtual css::table::CellAddress SAL_CALL getObjective() override;
+    virtual void SAL_CALL   setObjective( const css::table::CellAddress& _objective ) override;
+    virtual css::uno::Sequence< css::table::CellAddress > SAL_CALL getVariables() override;
+    virtual void SAL_CALL   setVariables( const css::uno::Sequence<
+                                    css::table::CellAddress >& _variables ) override;
+    virtual css::uno::Sequence< css::sheet::SolverConstraint > SAL_CALL getConstraints() override;
+    virtual void SAL_CALL   setConstraints( const css::uno::Sequence<
+                                    css::sheet::SolverConstraint >& _constraints ) override;
+    virtual sal_Bool SAL_CALL getMaximize() override;
+    virtual void SAL_CALL   setMaximize( sal_Bool _maximize ) override;
+
+    virtual sal_Bool SAL_CALL getSuccess() override;
+    virtual double SAL_CALL getResultValue() override;
+    virtual css::uno::Sequence< double > SAL_CALL getSolution() override;
+
+    virtual void SAL_CALL solve() override = 0;
+
+                            // XSolverDescription
+    virtual OUString SAL_CALL getComponentDescription() override = 0;
+    virtual OUString SAL_CALL getStatusDescription() override;
+    virtual OUString SAL_CALL getPropertyDescription( const OUString& aPropertyName ) override;
+
+                            // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName() override = 0;
+    virtual sal_Bool SAL_CALL supportsService( const OUString& ServiceName ) override;
+    virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
+};
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sccomp/source/solver/SwarmSolver.cxx b/sccomp/source/solver/SwarmSolver.cxx
new file mode 100644
index 0000000000..4aac9f81e2
--- /dev/null
+++ b/sccomp/source/solver/SwarmSolver.cxx
@@ -0,0 +1,595 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 <sal/config.h>
+
+#include <com/sun/star/frame/XModel.hpp>
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/sheet/XSpreadsheetDocument.hpp>
+#include <com/sun/star/sheet/XSpreadsheet.hpp>
+#include <com/sun/star/sheet/XSolver.hpp>
+#include <com/sun/star/sheet/XSolverDescription.hpp>
+#include <com/sun/star/table/CellAddress.hpp>
+#include <com/sun/star/table/CellContentType.hpp>
+#include <com/sun/star/table/XCell.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+
+#include <rtl/math.hxx>
+#include <cppuhelper/implbase.hxx>
+#include <cppuhelper/supportsservice.hxx>
+
+#include <comphelper/broadcasthelper.hxx>
+#include <comphelper/propertycontainer.hxx>
+#include <comphelper/proparrhlp.hxx>
+
+#include <cmath>
+#include <vector>
+#include <limits>
+#include <chrono>
+#include <random>
+
+#include <unotools/resmgr.hxx>
+
+#include "DifferentialEvolution.hxx"
+#include "ParticelSwarmOptimization.hxx"
+
+#include <strings.hrc>
+
+namespace com::sun::star::uno
+{
+class XComponentContext;
+}
+
+using namespace css;
+
+namespace
+{
+struct Bound
+{
+    double lower;
+    double upper;
+
+    Bound()
+        // float bounds should be low/high enough for all practical uses
+        // otherwise we are too far away from the solution
+        : lower(std::numeric_limits<float>::lowest())
+        , upper(std::numeric_limits<float>::max())
+    {
+    }
+
+    void updateBound(sheet::SolverConstraintOperator eOp, double fValue)
+    {
+        if (eOp == sheet::SolverConstraintOperator_LESS_EQUAL)
+        {
+            // if we set the bound multiple times use the one which includes both values
+            // for example bound values 100, 120, 150 -> use 100 -> the lowest one
+            if (fValue < upper)
+                upper = fValue;
+        }
+        else if (eOp == sheet::SolverConstraintOperator_GREATER_EQUAL)
+        {
+            if (fValue > lower)
+                lower = fValue;
+        }
+        else if (eOp == sheet::SolverConstraintOperator_EQUAL)
+        {
+            lower = fValue;
+            upper = fValue;
+        }
+    }
+};
+
+enum
+{
+    PROP_NONNEGATIVE,
+    PROP_INTEGER,
+    PROP_TIMEOUT,
+    PROP_ALGORITHM,
+};
+
+} // end anonymous namespace
+
+typedef cppu::WeakImplHelper<sheet::XSolver, sheet::XSolverDescription, lang::XServiceInfo>
+    SwarmSolver_Base;
+
+namespace
+{
+class SwarmSolver : public comphelper::OMutexAndBroadcastHelper,
+                    public comphelper::OPropertyContainer,
+                    public comphelper::OPropertyArrayUsageHelper<SwarmSolver>,
+                    public SwarmSolver_Base
+{
+private:
+    uno::Reference<sheet::XSpreadsheetDocument> mxDocument;
+    table::CellAddress maObjective;
+    uno::Sequence<table::CellAddress> maVariables;
+    uno::Sequence<sheet::SolverConstraint> maConstraints;
+    bool mbMaximize;
+
+    // set via XPropertySet
+    bool mbNonNegative;
+    bool mbInteger;
+    sal_Int32 mnTimeout;
+    sal_Int32 mnAlgorithm;
+
+    // results
+    bool mbSuccess;
+    double mfResultValue;
+
+    uno::Sequence<double> maSolution;
+    OUString maStatus;
+
+    std::vector<Bound> maBounds;
+    std::vector<sheet::SolverConstraint> maNonBoundedConstraints;
+
+private:
+    static OUString getResourceString(TranslateId aId);
+
+    uno::Reference<table::XCell> getCell(const table::CellAddress& rPosition);
+    void setValue(const table::CellAddress& rPosition, double fValue);
+    double getValue(const table::CellAddress& rPosition);
+
+public:
+    SwarmSolver()
+        : OPropertyContainer(GetBroadcastHelper())
+        , mbMaximize(true)
+        , mbNonNegative(false)
+        , mbInteger(false)
+        , mnTimeout(60000)
+        , mnAlgorithm(0)
+        , mbSuccess(false)
+        , mfResultValue(0.0)
+    {
+        registerProperty("NonNegative", PROP_NONNEGATIVE, 0, &mbNonNegative,
+                         cppu::UnoType<decltype(mbNonNegative)>::get());
+        registerProperty("Integer", PROP_INTEGER, 0, &mbInteger,
+                         cppu::UnoType<decltype(mbInteger)>::get());
+        registerProperty("Timeout", PROP_TIMEOUT, 0, &mnTimeout,
+                         cppu::UnoType<decltype(mnTimeout)>::get());
+        registerProperty("Algorithm", PROP_ALGORITHM, 0, &mnAlgorithm,
+                         cppu::UnoType<decltype(mnAlgorithm)>::get());
+    }
+
+    DECLARE_XINTERFACE()
+    DECLARE_XTYPEPROVIDER()
+
+    virtual uno::Reference<beans::XPropertySetInfo> SAL_CALL getPropertySetInfo() override
+    {
+        return createPropertySetInfo(getInfoHelper());
+    }
+    // OPropertySetHelper
+    virtual cppu::IPropertyArrayHelper& SAL_CALL getInfoHelper() override
+    {
+        return *getArrayHelper();
+    }
+    // OPropertyArrayUsageHelper
+    virtual cppu::IPropertyArrayHelper* createArrayHelper() const override
+    {
+        uno::Sequence<beans::Property> aProperties;
+        describeProperties(aProperties);
+        return new cppu::OPropertyArrayHelper(aProperties);
+    }
+
+    // XSolver
+    virtual uno::Reference<sheet::XSpreadsheetDocument> SAL_CALL getDocument() override
+    {
+        return mxDocument;
+    }
+    virtual void SAL_CALL
+    setDocument(const uno::Reference<sheet::XSpreadsheetDocument>& rDocument) override
+    {
+        mxDocument = rDocument;
+    }
+
+    virtual table::CellAddress SAL_CALL getObjective() override { return maObjective; }
+    virtual void SAL_CALL setObjective(const table::CellAddress& rObjective) override
+    {
+        maObjective = rObjective;
+    }
+
+    virtual uno::Sequence<table::CellAddress> SAL_CALL getVariables() override
+    {
+        return maVariables;
+    }
+    virtual void SAL_CALL setVariables(const uno::Sequence<table::CellAddress>& rVariables) override
+    {
+        maVariables = rVariables;
+    }
+
+    virtual uno::Sequence<sheet::SolverConstraint> SAL_CALL getConstraints() override
+    {
+        return maConstraints;
+    }
+    virtual void SAL_CALL
+    setConstraints(const uno::Sequence<sheet::SolverConstraint>& rConstraints) override
+    {
+        maConstraints = rConstraints;
+    }
+
+    virtual sal_Bool SAL_CALL getMaximize() override { return mbMaximize; }
+    virtual void SAL_CALL setMaximize(sal_Bool bMaximize) override { mbMaximize = bMaximize; }
+
+    virtual sal_Bool SAL_CALL getSuccess() override { return mbSuccess; }
+    virtual double SAL_CALL getResultValue() override { return mfResultValue; }
+
+    virtual uno::Sequence<double> SAL_CALL getSolution() override { return maSolution; }
+
+    virtual void SAL_CALL solve() override;
+
+    // XSolverDescription
+    virtual OUString SAL_CALL getComponentDescription() override
+    {
+        return SwarmSolver::getResourceString(RID_SWARM_SOLVER_COMPONENT);
+    }
+
+    virtual OUString SAL_CALL getStatusDescription() override { return maStatus; }
+
+    virtual OUString SAL_CALL getPropertyDescription(const OUString& rPropertyName) override
+    {
+        TranslateId pResId;
+        switch (getInfoHelper().getHandleByName(rPropertyName))
+        {
+            case PROP_NONNEGATIVE:
+                pResId = RID_PROPERTY_NONNEGATIVE;
+                break;
+            case PROP_INTEGER:
+                pResId = RID_PROPERTY_INTEGER;
+                break;
+            case PROP_TIMEOUT:
+                pResId = RID_PROPERTY_TIMEOUT;
+                break;
+            case PROP_ALGORITHM:
+                pResId = RID_PROPERTY_ALGORITHM;
+                break;
+            default:
+                break;
+        }
+        return SwarmSolver::getResourceString(pResId);
+    }
+
+    // XServiceInfo
+    virtual OUString SAL_CALL getImplementationName() override
+    {
+        return "com.sun.star.comp.Calc.SwarmSolver";
+    }
+
+    sal_Bool SAL_CALL supportsService(const OUString& rServiceName) override
+    {
+        return cppu::supportsService(this, rServiceName);
+    }
+
+    uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override
+    {
+        return { "com.sun.star.sheet.Solver" };
+    }
+
+private:
+    void applyVariables(std::vector<double> const& rVariables);
+    bool doesViolateConstraints();
+
+public:
+    double calculateFitness(std::vector<double> const& rVariables);
+    size_t getDimensionality() const;
+    void initializeVariables(std::vector<double>& rVariables, std::mt19937& rGenerator);
+    double clampVariable(size_t nVarIndex, double fValue);
+    double boundVariable(size_t nVarIndex, double fValue);
+};
+}
+
+OUString SwarmSolver::getResourceString(TranslateId aId)
+{
+    if (!aId)
+        return OUString();
+
+    return Translate::get(aId, Translate::Create("scc"));
+}
+
+uno::Reference<table::XCell> SwarmSolver::getCell(const table::CellAddress& rPosition)
+{
+    uno::Reference<container::XIndexAccess> xSheets(mxDocument->getSheets(), uno::UNO_QUERY);
+    uno::Reference<sheet::XSpreadsheet> xSheet(xSheets->getByIndex(rPosition.Sheet),
+                                               uno::UNO_QUERY);
+    return xSheet->getCellByPosition(rPosition.Column, rPosition.Row);
+}
+
+void SwarmSolver::setValue(const table::CellAddress& rPosition, double fValue)
+{
+    getCell(rPosition)->setValue(fValue);
+}
+
+double SwarmSolver::getValue(const table::CellAddress& rPosition)
+{
+    return getCell(rPosition)->getValue();
+}
+
+IMPLEMENT_FORWARD_XINTERFACE2(SwarmSolver, SwarmSolver_Base, OPropertyContainer)
+IMPLEMENT_FORWARD_XTYPEPROVIDER2(SwarmSolver, SwarmSolver_Base, OPropertyContainer)
+
+void SwarmSolver::applyVariables(std::vector<double> const& rVariables)
+{
+    for (sal_Int32 i = 0; i < maVariables.getLength(); ++i)
+    {
+        setValue(maVariables[i], rVariables[i]);
+    }
+}
+
+double SwarmSolver::calculateFitness(std::vector<double> const& rVariables)
+{
+    applyVariables(rVariables);
+
+    if (doesViolateConstraints())
+        return std::numeric_limits<float>::lowest();
+
+    double x = getValue(maObjective);
+
+    if (mbMaximize)
+        return x;
+    else
+        return -x;
+}
+
+void SwarmSolver::initializeVariables(std::vector<double>& rVariables, std::mt19937& rGenerator)
+{
+    int nTry = 1;
+    bool bConstraintsOK = false;
+
+    while (!bConstraintsOK && nTry < 10)
+    {
+        size_t noVariables(maVariables.getLength());
+
+        rVariables.resize(noVariables);
+
+        for (size_t i = 0; i < noVariables; ++i)
+        {
+            Bound const& rBound = maBounds[i];
+            if (mbInteger)
+            {
+                sal_Int64 intLower(rBound.lower);
+                sal_Int64 intUpper(rBound.upper);
+                std::uniform_int_distribution<sal_Int64> random(intLower, intUpper);
+                rVariables[i] = double(random(rGenerator));
+            }
+            else
+            {
+                std::uniform_real_distribution<double> random(rBound.lower, rBound.upper);
+                rVariables[i] = random(rGenerator);
+            }
+        }
+
+        applyVariables(rVariables);
+
+        bConstraintsOK = !doesViolateConstraints();
+        nTry++;
+    }
+}
+
+double SwarmSolver::clampVariable(size_t nVarIndex, double fValue)
+{
+    Bound const& rBound = maBounds[nVarIndex];
+    double fResult = std::clamp(fValue, rBound.lower, rBound.upper);
+
+    if (mbInteger)
+        return std::trunc(fResult);
+
+    return fResult;
+}
+
+double SwarmSolver::boundVariable(size_t nVarIndex, double fValue)
+{
+    Bound const& rBound = maBounds[nVarIndex];
+    // double fResult = std::max(std::min(fValue, rBound.upper), rBound.lower);
+    double fResult = fValue;
+    while (fResult < rBound.lower || fResult > rBound.upper)
+    {
+        if (fResult < rBound.lower)
+            fResult = rBound.upper - (rBound.lower - fResult);
+        if (fResult > rBound.upper)
+            fResult = (fResult - rBound.upper) + rBound.lower;
+    }
+
+    if (mbInteger)
+        return std::trunc(fResult);
+
+    return fResult;
+}
+
+size_t SwarmSolver::getDimensionality() const { return maVariables.getLength(); }
+
+bool SwarmSolver::doesViolateConstraints()
+{
+    for (const sheet::SolverConstraint& rConstraint : maNonBoundedConstraints)
+    {
+        double fLeftValue = getValue(rConstraint.Left);
+        double fRightValue = 0.0;
+
+        table::CellAddress aCellAddress;
+
+        if (rConstraint.Right >>= aCellAddress)
+        {
+            fRightValue = getValue(aCellAddress);
+        }
+        else if (rConstraint.Right >>= fRightValue)
+        {
+            // empty
+        }
+        else
+        {
+            return false;
+        }
+
+        sheet::SolverConstraintOperator eOp = rConstraint.Operator;
+        switch (eOp)
+        {
+            case sheet::SolverConstraintOperator_LESS_EQUAL:
+            {
+                if (fLeftValue > fRightValue)
+                    return true;
+            }
+            break;
+            case sheet::SolverConstraintOperator_GREATER_EQUAL:
+            {
+                if (fLeftValue < fRightValue)
+                    return true;
+            }
+            break;
+            case sheet::SolverConstraintOperator_EQUAL:
+            {
+                if (!rtl::math::approxEqual(fLeftValue, fRightValue))
+                    return true;
+            }
+            break;
+            default:
+                break;
+        }
+    }
+    return false;
+}
+
+namespace
+{
+template <typename SwarmAlgorithm> class SwarmRunner
+{
+private:
+    SwarmAlgorithm& mrAlgorithm;
+    double mfTimeout;
+
+    static constexpr size_t mnPopulationSize = 40;
+    static constexpr int constNumberOfGenerationsWithoutChange = 50;
+
+    std::chrono::high_resolution_clock::time_point maStart;
+    std::chrono::high_resolution_clock::time_point maEnd;
+
+public:
+    SwarmRunner(SwarmAlgorithm& rAlgorithm)
+        : mrAlgorithm(rAlgorithm)
+        , mfTimeout(5000)
+    {
+    }
+
+    void setTimeout(double fTimeout) { mfTimeout = fTimeout; }
+
+    std::vector<double> const& solve()
+    {
+        using std::chrono::duration_cast;
+        using std::chrono::high_resolution_clock;
+        using std::chrono::milliseconds;
+
+        mrAlgorithm.initialize();
+
+        maEnd = maStart = high_resolution_clock::now();
+
+        int nLastChange = 0;
+
+        while ((mrAlgorithm.getGeneration() - nLastChange) < constNumberOfGenerationsWithoutChange
+               && duration_cast<milliseconds>(maEnd - maStart).count() < mfTimeout)
+        {
+            bool bChange = mrAlgorithm.next();
+
+            if (bChange)
+                nLastChange = mrAlgorithm.getGeneration();
+
+            maEnd = high_resolution_clock::now();
+        }
+        return mrAlgorithm.getResult();
+    }
+};
+}
+
+void SAL_CALL SwarmSolver::solve()
+{
+    uno::Reference<frame::XModel> xModel(mxDocument, uno::UNO_QUERY_THROW);
+
+    maStatus.clear();
+    mbSuccess = false;
+    if (!maVariables.getLength())
+        return;
+
+    maBounds.resize(maVariables.getLength());
+
+    xModel->lockControllers();
+
+    if (mbNonNegative)
+    {
+        for (Bound& rBound : maBounds)
+            rBound.lower = 0;
+    }
+
+    // Determine variable bounds
+    for (sheet::SolverConstraint const& rConstraint : std::as_const(maConstraints))
+    {
+        table::CellAddress aLeftCellAddress = rConstraint.Left;
+        sheet::SolverConstraintOperator eOp = rConstraint.Operator;
+
+        size_t index = 0;
+        bool bFoundVariable = false;
+        for (const table::CellAddress& rVariableCell : std::as_const(maVariables))
+        {
+            if (aLeftCellAddress == rVariableCell)
+            {
+                bFoundVariable = true;
+                table::CellAddress aCellAddress;
+                double fValue;
+
+                if (rConstraint.Right >>= aCellAddress)
+                {
+                    uno::Reference<table::XCell> xCell = getCell(aCellAddress);
+                    if (xCell->getType() == table::CellContentType_VALUE)
+                    {
+                        maBounds[index].updateBound(eOp, xCell->getValue());
+                    }
+                    else
+                    {
+                        maNonBoundedConstraints.push_back(rConstraint);
+                    }
+                }
+                else if (rConstraint.Right >>= fValue)
+                {
+                    maBounds[index].updateBound(eOp, fValue);
+                }
+            }
+            index++;
+        }
+        if (!bFoundVariable)
+            maNonBoundedConstraints.push_back(rConstraint);
+    }
+
+    std::vector<double> aSolution;
+
+    if (mnAlgorithm == 0)
+    {
+        DifferentialEvolutionAlgorithm<SwarmSolver> aDE(*this, 50);
+        SwarmRunner<DifferentialEvolutionAlgorithm<SwarmSolver>> aEvolution(aDE);
+        aEvolution.setTimeout(mnTimeout);
+        aSolution = aEvolution.solve();
+    }
+    else
+    {
+        ParticleSwarmOptimizationAlgorithm<SwarmSolver> aPSO(*this, 100);
+        SwarmRunner<ParticleSwarmOptimizationAlgorithm<SwarmSolver>> aSwarmSolver(aPSO);
+        aSwarmSolver.setTimeout(mnTimeout);
+        aSolution = aSwarmSolver.solve();
+    }
+
+    xModel->unlockControllers();
+
+    mbSuccess = true;
+
+    maSolution.realloc(aSolution.size());
+    std::copy(aSolution.begin(), aSolution.end(), maSolution.getArray());
+}
+
+extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface*
+com_sun_star_comp_Calc_SwarmSolver_get_implementation(uno::XComponentContext*,
+                                                      uno::Sequence<uno::Any> const&)
+{
+    return cppu::acquire(new SwarmSolver());
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/sccomp/source/solver/solver.component b/sccomp/source/solver/solver.component
new file mode 100644
index 0000000000..496be66284
--- /dev/null
+++ b/sccomp/source/solver/solver.component
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * 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/.
+ -->
+<component loader="com.sun.star.loader.SharedLibrary" environment="@CPPU_ENV@"
+    xmlns="http://openoffice.org/2010/uno-components">
+  <implementation name="com.sun.star.comp.Calc.CoinMPSolver"
+      constructor="com_sun_star_comp_Calc_CoinMPSolver_get_implementation">
+    <service name="com.sun.star.sheet.Solver"/>
+    <optional/>
+  </implementation>
+  <implementation name="com.sun.star.comp.Calc.LpsolveSolver"
+      constructor="com_sun_star_comp_Calc_LpsolveSolver_get_implementation">
+    <service name="com.sun.star.sheet.Solver"/>
+    <optional/>
+  </implementation>
+  <implementation name="com.sun.star.comp.Calc.SwarmSolver"
+      constructor="com_sun_star_comp_Calc_SwarmSolver_get_implementation">
+    <service name="com.sun.star.sheet.Solver"/>
+  </implementation>
+</component>
diff --git a/sccomp/source/solver/solver.component.coinmp b/sccomp/source/solver/solver.component.coinmp
new file mode 100644
index 0000000000..1ced6f61be
--- /dev/null
+++ b/sccomp/source/solver/solver.component.coinmp
@@ -0,0 +1,7 @@
+# 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/.
+
+com.sun.star.comp.Calc.CoinMPSolver
diff --git a/sccomp/source/solver/solver.component.lpsolve b/sccomp/source/solver/solver.component.lpsolve
new file mode 100644
index 0000000000..3b571fbc32
--- /dev/null
+++ b/sccomp/source/solver/solver.component.lpsolve
@@ -0,0 +1,7 @@
+# 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/.
+
+com.sun.star.comp.Calc.LpsolveSolver