scmatrix.hxx

Go to the documentation of this file.

/* -*- 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 "address.hxx"
#include "matrixoperators.hxx"
#include "types.hxx"
#include <formula/errorcodes.hxx>
#include "scdllapi.h"
#include <svl/sharedstring.hxx>
#include <svl/sharedstringpool.hxx>
 
#include <memory>
#include <utility>
#include <vector>
 
#define DEBUG_MATRIX 0
 
class ScInterpreter;
class SvNumberFormatter;
class ScMatrixImpl;
enum class FormulaError : sal_uInt16;
 
namespace sc {
 
struct Compare;
struct CompareOptions;
 
}
 
struct ScMatrixValue
{
    double fVal;
    svl::SharedString aStr;
    ScMatValType nType;
 
    const svl::SharedString& GetString() const { return aStr; }
 
    FormulaError GetError() const { return GetDoubleErrorValue(fVal); }
 
    bool GetBoolean() const         { return fVal != 0.0; }
 
    ScMatrixValue() : fVal(0.0), nType(ScMatValType::Empty) {}
    ScMatrixValue(const ScMatrixValue& r) = default;
    ScMatrixValue& operator= (const ScMatrixValue& r) = default;
 
    bool operator== (const ScMatrixValue& r) const
    {
        if (nType != r.nType)
            return false;
 
        switch (nType)
        {
            case ScMatValType::Value:
            case ScMatValType::Boolean:
                return fVal == r.fVal;
            break;
            default:
                ;
        }
 
        return aStr == r.aStr;
    }
 
    bool operator!= (const ScMatrixValue& r) const
    {
        return !operator==(r);
    }
};
 
class SC_DLLPUBLIC ScMatrix final
{
    friend class ScMatrixImpl;
 
    mutable size_t  nRefCnt;    // reference count
    mutable bool    mbCloneIfConst; // Whether the matrix is cloned with a CloneIfConst() call.
    std::unique_ptr<ScMatrixImpl> pImpl;
 
    ScMatrix( const ScMatrix& ) = delete;
    ScMatrix& operator=( const ScMatrix&) = delete;
 
public:
    ScMatrix(SCSIZE nC, SCSIZE nR);
    ScMatrix(SCSIZE nC, SCSIZE nR, double fInitVal);
    ScMatrix( size_t nC, size_t nR, const std::vector<double>& rInitVals );
    ~ScMatrix();
 
    typedef std::function<void(size_t, size_t, double)> DoubleOpFunction;
    typedef std::function<void(size_t, size_t, bool)> BoolOpFunction;
    typedef std::function<void(size_t, size_t, svl::SharedString)> StringOpFunction;
    typedef std::function<void(size_t, size_t)> EmptyOpFunction;
    typedef std::function<double(double, double)> CalculateOpFunction;
 
    template<typename tRes>
    struct IterateResultMultiple
    {
        std::vector<tRes> maAccumulator;
        size_t mnCount;
 
        IterateResultMultiple(size_t nCount) :
            maAccumulator(0), mnCount(nCount) {}
    };
    typedef IterateResultMultiple<KahanSum> KahanIterateResultMultiple;
    typedef IterateResultMultiple<double> DoubleIterateResultMultiple;
 
    template<typename tRes>
    struct IterateResult
    {
        tRes maAccumulator;
        size_t mnCount;
 
        IterateResult(tRes fAccumulator, size_t nCount)
            : maAccumulator(fAccumulator), mnCount(nCount) {}
    };
    typedef IterateResult<KahanSum> KahanIterateResult;
    typedef IterateResult<double> DoubleIterateResult;
 
 
    bool static IsSizeAllocatable( SCSIZE nC, SCSIZE nR );
 
    static bool IsValueType( ScMatValType nType )
    {
        return nType <= ScMatValType::Boolean;
    }
 
    static bool IsBooleanType( ScMatValType nType )
    {
        return nType == ScMatValType::Boolean;
    }
 
    static bool IsNonValueType( ScMatValType nType )
    {
        return bool(nType & ScMatValType::NonvalueMask);
    }
 
    static bool IsRealStringType( ScMatValType nType )
    {
        return (nType & ScMatValType::NonvalueMask) == ScMatValType::String;
    }
 
    static bool IsEmptyType( ScMatValType nType )
    {
        return (nType & ScMatValType::NonvalueMask) == ScMatValType::Empty;
    }
 
    static bool IsEmptyPathType( ScMatValType nType )
    {
        return (nType & ScMatValType::NonvalueMask) == ScMatValType::EmptyPath;
    }
 
    ScMatrix* Clone() const;
 
    ScMatrix* CloneIfConst();
 
    void SetMutable();
 
    void SetImmutable() const;
 
    void Resize(SCSIZE nC, SCSIZE nR);
 
    void Resize(SCSIZE nC, SCSIZE nR, double fVal);
 
    ScMatrix* CloneAndExtend(SCSIZE nNewCols, SCSIZE nNewRows) const;
 
    void IncRef() const;
    void DecRef() const;
 
    void SetErrorInterpreter( ScInterpreter* p);
    void GetDimensions( SCSIZE& rC, SCSIZE& rR) const;
    SCSIZE GetElementCount() const;
    bool ValidColRow( SCSIZE nC, SCSIZE nR) const;
 
    bool ValidColRowReplicated( SCSIZE & rC, SCSIZE & rR ) const;
 
    bool ValidColRowOrReplicated( SCSIZE & rC, SCSIZE & rR ) const;
 
    void PutDouble( double fVal, SCSIZE nC, SCSIZE nR);
    void PutDouble( double fVal, SCSIZE nIndex);
    void PutDouble(const double* pArray, size_t nLen, SCSIZE nC, SCSIZE nR);
 
    void PutString( const svl::SharedString& rStr, SCSIZE nC, SCSIZE nR) ;
    void PutString( const svl::SharedString& rStr, SCSIZE nIndex) ;
    void PutString( const svl::SharedString* pArray, size_t nLen, SCSIZE nC, SCSIZE nR) ;
 
    void PutEmpty( SCSIZE nC, SCSIZE nR);
 
    void PutEmptyPath( SCSIZE nC, SCSIZE nR) ;
    void PutError( FormulaError nErrorCode, SCSIZE nC, SCSIZE nR ) ;
    void PutBoolean( bool bVal, SCSIZE nC, SCSIZE nR) ;
 
    void FillDouble( double fVal,
            SCSIZE nC1, SCSIZE nR1, SCSIZE nC2, SCSIZE nR2 ) ;
 
    void PutDoubleVector( const ::std::vector< double > & rVec, SCSIZE nC, SCSIZE nR ) ;
 
    void PutStringVector( const ::std::vector< svl::SharedString > & rVec, SCSIZE nC, SCSIZE nR ) ;
 
    void PutEmptyVector( SCSIZE nCount, SCSIZE nC, SCSIZE nR ) ;
 
    void PutEmptyResultVector( SCSIZE nCount, SCSIZE nC, SCSIZE nR ) ;
 
    void PutEmptyPathVector( SCSIZE nCount, SCSIZE nC, SCSIZE nR ) ;
 
    FormulaError GetError( SCSIZE nC, SCSIZE nR) const ;
 
    FormulaError GetErrorIfNotString( SCSIZE nC, SCSIZE nR) const
        { return IsValue( nC, nR) ? GetError( nC, nR) : FormulaError::NONE; }
 
    double GetDouble( SCSIZE nC, SCSIZE nR) const ;
    double GetDouble( SCSIZE nIndex) const ;
    double GetDoubleWithStringConversion( SCSIZE nC, SCSIZE nR ) const ;
 
    svl::SharedString GetString( SCSIZE nC, SCSIZE nR) const ;
    svl::SharedString GetString( SCSIZE nIndex) const ;
 
    svl::SharedString GetString( SvNumberFormatter& rFormatter, SCSIZE nC, SCSIZE nR) const ;
 
    ScMatrixValue Get( SCSIZE nC, SCSIZE nR) const ;
 
    bool IsStringOrEmpty( SCSIZE nIndex ) const ;
 
    bool IsStringOrEmpty( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsEmpty( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsEmptyCell( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsEmptyResult( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsEmptyPath( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsValue( SCSIZE nIndex ) const ;
 
    bool IsValue( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsValueOrEmpty( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsBoolean( SCSIZE nC, SCSIZE nR ) const ;
 
    bool IsNumeric() const ;
 
    void MatTrans( const ScMatrix& mRes) const ;
    void MatCopy ( const ScMatrix& mRes) const ;
 
    // Convert ScInterpreter::CompareMat values (-1,0,1) to boolean values
    void CompareEqual() ;
    void CompareNotEqual() ;
    void CompareLess() ;
    void CompareGreater() ;
    void CompareLessEqual() ;
    void CompareGreaterEqual() ;
 
    double And() const ;       // logical AND of all matrix values, or NAN
    double Or() const ;        // logical OR of all matrix values, or NAN
    double Xor() const ;       // logical XOR of all matrix values, or NAN
 
    KahanIterateResult Sum( bool bTextAsZero, bool bIgnoreErrorValues = false ) const ;
    KahanIterateResult SumSquare( bool bTextAsZero, bool bIgnoreErrorValues = false ) const ;
    DoubleIterateResult Product( bool bTextAsZero, bool bIgnoreErrorValues = false ) const ;
    size_t Count(bool bCountStrings, bool bCountErrors, bool bIgnoreEmptyStrings = false) const ;
    size_t MatchDoubleInColumns(double fValue, size_t nCol1, size_t nCol2) const ;
    size_t MatchStringInColumns(const svl::SharedString& rStr, size_t nCol1, size_t nCol2) const ;
 
    double GetMaxValue( bool bTextAsZero, bool bIgnoreErrorValues = false ) const ;
    double GetMinValue( bool bTextAsZero, bool bIgnoreErrorValues = false ) const ;
    double GetGcd() const ;
    double GetLcm() const ;
 
    ScMatrixRef CompareMatrix(
        sc::Compare& rComp, size_t nMatPos, sc::CompareOptions* pOptions ) const ;
 
    void GetDoubleArray( std::vector<double>& rArray, bool bEmptyAsZero = true ) const ;
    void MergeDoubleArrayMultiply( std::vector<double>& rArray ) const ;
 
    void NotOp(const ScMatrix& rMat) ;
    void NegOp(const ScMatrix& rMat) ;
    void AddOp(double fVal, const ScMatrix& rMat) ;
    void SubOp(bool bFlag, double fVal, const ScMatrix& rMat) ;
    void MulOp(double fVal, const ScMatrix& rMat) ;
    void DivOp(bool bFlag, double fVal, const ScMatrix& rMat) ;
    void PowOp(bool bFlag, double fVal, const ScMatrix& rMat) ;
 
    KahanIterateResultMultiple CollectKahan(const std::vector<sc::op::kOp>& aOp) ;
 
    void ExecuteOperation(const std::pair<size_t, size_t>& rStartPos, const std::pair<size_t, size_t>& rEndPos,
            DoubleOpFunction aDoubleFunc, BoolOpFunction aBoolFunc, StringOpFunction aStringFunc,
            EmptyOpFunction aEmptyFunc) const ;
 
    void MatConcat(SCSIZE nMaxCol, SCSIZE nMaxRow, const ScMatrixRef& xMat1, const ScMatrixRef& xMat2,
            SvNumberFormatter& rFormatter, svl::SharedStringPool& rPool) ;
 
    void ExecuteBinaryOp(SCSIZE nMaxCol, SCSIZE nMaxRow, const ScMatrix& rInputMat1, const ScMatrix& rInputMat2,
            ScInterpreter* pInterpreter, CalculateOpFunction op);
 
#if DEBUG_MATRIX
    void Dump() const;
#endif
};
 
inline void intrusive_ptr_add_ref(const ScMatrix* p)
{
    p->IncRef();
}
 
inline void intrusive_ptr_release(const ScMatrix* p)
{
    p->DecRef();
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */