sc/source/core/tool/interpr5.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: interpr5.cxx,v $
  10  * $Revision: 1.33.36.3 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sc.hxx"
  33
  34 // INCLUDE ---------------------------------------------------------------
  35
  36 #ifndef INCLUDED_RTL_MATH_HXX
  37 #include <rtl/math.hxx>
  38 #endif
  39 #include <rtl/logfile.hxx>
  40 #include <string.h>
  41 #include <math.h>
  42 #include <stdio.h>
  43
  44 #if OSL_DEBUG_LEVEL > 1
  45 #include <stdio.h>
  46 #endif
  47 #include <unotools/bootstrap.hxx>
  48 #include <svtools/zforlist.hxx>
  49
  50 #include "interpre.hxx"
  51 #include "global.hxx"
  52 #include "compiler.hxx"
  53 #include "cell.hxx"
  54 #include "document.hxx"
  55 #include "dociter.hxx"
  56 #include "scmatrix.hxx"
  57 #include "globstr.hrc"
  58 #include "cellkeytranslator.hxx"
  59 #include "osversiondef.hxx"
  60
  61 #include <string.h>
  62 #include <math.h>
  63 #include <vector>
  64
  65 using ::std::vector;
  66 using namespace formula;
  67
  68 const double fInvEpsilon = 1.0E-7;
  69
  70 // -----------------------------------------------------------------------
  71     struct MatrixAdd : public ::std::binary_function<double,double,double>
  72     {
  73         inline double operator() (const double& lhs, const double& rhs) const
  74         {
  75             return ::rtl::math::approxAdd( lhs,rhs);
  76         }
  77     };
  78     struct MatrixSub : public ::std::binary_function<double,double,double>
  79     {
  80         inline double operator() (const double& lhs, const double& rhs) const
  81         {
  82             return ::rtl::math::approxSub( lhs,rhs);
  83         }
  84     };
  85     struct MatrixMul : public ::std::binary_function<double,double,double>
  86     {
  87         inline double operator() (const double& lhs, const double& rhs) const
  88         {
  89             return lhs * rhs;
  90         }
  91     };
  92     struct MatrixDiv : public ::std::binary_function<double,double,double>
  93     {
  94         inline double operator() (const double& lhs, const double& rhs) const
  95         {
  96             return ScInterpreter::div( lhs,rhs);
  97         }
  98     };
  99     struct MatrixPow : public ::std::binary_function<double,double,double>
 100     {
 101         inline double operator() (const double& lhs, const double& rhs) const
 102         {
 103             return ::pow( lhs,rhs);
 104         }
 105     };
 106
 107 double ScInterpreter::ScGetGCD(double fx, double fy)
 108 {
 109     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::div" );
 110     // By ODFF definition GCD(0,a) => a. This is also vital for the code in
 111     // ScGCD() to work correctly with a preset fy=0.0
 112     if (fy == 0.0)
 113         return fx;
 114     else if (fx == 0.0)
 115         return fy;
 116     else
 117     {
 118         double fz = fmod(fx, fy);
 119         while (fz > 0.0)
 120         {
 121             fx = fy;
 122             fy = fz;
 123             fz = fmod(fx, fy);
 124         }
 125         return fy;
 126     }
 127 }
 128
 129 void ScInterpreter::ScGCD()
 130 {
 131     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGCD" );
 132     short nParamCount = GetByte();
 133     if ( MustHaveParamCountMin( nParamCount, 1 ) )
 134     {
 135         double fx, fy = 0.0;
 136         ScRange aRange;
 137         size_t nRefInList = 0;
 138         while (!nGlobalError && nParamCount-- > 0)
 139         {
 140             switch (GetStackType())
 141             {
 142                 case svDouble :
 143                 case svString:
 144                 case svSingleRef:
 145                 {
 146                     fx = ::rtl::math::approxFloor( GetDouble());
 147                     if (fx < 0.0)
 148                     {
 149                         PushIllegalArgument();
 150                         return;
 151                     }
 152                     fy = ScGetGCD(fx, fy);
 153                 }
 154                 break;
 155                 case svDoubleRef :
 156                 case svRefList :
 157                 {
 158                     USHORT nErr = 0;
 159                     PopDoubleRef( aRange, nParamCount, nRefInList);
 160                     double nCellVal;
 161                     ScValueIterator aValIter(pDok, aRange, glSubTotal);
 162                     if (aValIter.GetFirst(nCellVal, nErr))
 163                     {
 164                         do
 165                         {
 166                             fx = ::rtl::math::approxFloor( nCellVal);
 167                             if (fx < 0.0)
 168                             {
 169                                 PushIllegalArgument();
 170                                 return;
 171                             }
 172                             fy = ScGetGCD(fx, fy);
 173                         } while (nErr == 0 && aValIter.GetNext(nCellVal, nErr));
 174                     }
 175                     SetError(nErr);
 176                 }
 177                 break;
 178                 case svMatrix :
 179                 {
 180                     ScMatrixRef pMat = PopMatrix();
 181                     if (pMat)
 182                     {
 183                         SCSIZE nC, nR;
 184                         pMat->GetDimensions(nC, nR);
 185                         if (nC == 0 || nR == 0)
 186                             SetError(errIllegalArgument);
 187                         else
 188                         {
 189                             SCSIZE nCount = nC * nR;
 190                             for ( SCSIZE j = 0; j < nCount; j++ )
 191                             {
 192                                 if (!pMat->IsValue(j))
 193                                 {
 194                                     PushIllegalArgument();
 195                                     return;
 196                                 }
 197                                 fx = ::rtl::math::approxFloor( pMat->GetDouble(j));
 198                                 if (fx < 0.0)
 199                                 {
 200                                     PushIllegalArgument();
 201                                     return;
 202                                 }
 203                                 fy = ScGetGCD(fx, fy);
 204                             }
 205                         }
 206                     }
 207                 }
 208                 break;
 209                 default : SetError(errIllegalParameter); break;
 210             }
 211         }
 212         PushDouble(fy);
 213     }
 214 }
 215
 216 void ScInterpreter:: ScLCM()
 217 {
 218     short nParamCount = GetByte();
 219     if ( MustHaveParamCountMin( nParamCount, 1 ) )
 220     {
 221         double fx, fy = 1.0;
 222         ScRange aRange;
 223         size_t nRefInList = 0;
 224         while (!nGlobalError && nParamCount-- > 0)
 225         {
 226             switch (GetStackType())
 227             {
 228                 case svDouble :
 229                 case svString:
 230                 case svSingleRef:
 231                 {
 232                     fx = ::rtl::math::approxFloor( GetDouble());
 233                     if (fx < 0.0)
 234                     {
 235                         PushIllegalArgument();
 236                         return;
 237                     }
 238                     if (fx == 0.0 || fy == 0.0)
 239                         fy = 0.0;
 240                     else
 241                         fy = fx * fy / ScGetGCD(fx, fy);
 242                 }
 243                 break;
 244                 case svDoubleRef :
 245                 case svRefList :
 246                 {
 247                     USHORT nErr = 0;
 248                     PopDoubleRef( aRange, nParamCount, nRefInList);
 249                     double nCellVal;
 250                     ScValueIterator aValIter(pDok, aRange, glSubTotal);
 251                     if (aValIter.GetFirst(nCellVal, nErr))
 252                     {
 253                         do
 254                         {
 255                             fx = ::rtl::math::approxFloor( nCellVal);
 256                             if (fx < 0.0)
 257                             {
 258                                 PushIllegalArgument();
 259                                 return;
 260                             }
 261                             if (fx == 0.0 || fy == 0.0)
 262                                 fy = 0.0;
 263                             else
 264                                 fy = fx * fy / ScGetGCD(fx, fy);
 265                         } while (nErr == 0 && aValIter.GetNext(nCellVal, nErr));
 266                     }
 267                     SetError(nErr);
 268                 }
 269                 break;
 270                 case svMatrix :
 271                 {
 272                     ScMatrixRef pMat = PopMatrix();
 273                     if (pMat)
 274                     {
 275                         SCSIZE nC, nR;
 276                         pMat->GetDimensions(nC, nR);
 277                         if (nC == 0 || nR == 0)
 278                             SetError(errIllegalArgument);
 279                         else
 280                         {
 281                             SCSIZE nCount = nC * nR;
 282                             for ( SCSIZE j = 0; j < nCount; j++ )
 283                             {
 284                                 if (!pMat->IsValue(j))
 285                                 {
 286                                     PushIllegalArgument();
 287                                     return;
 288                                 }
 289                                 fx = ::rtl::math::approxFloor( pMat->GetDouble(j));
 290                                 if (fx < 0.0)
 291                                 {
 292                                     PushIllegalArgument();
 293                                     return;
 294                                 }
 295                                 if (fx == 0.0 || fy == 0.0)
 296                                     fy = 0.0;
 297                                 else
 298                                     fy = fx * fy / ScGetGCD(fx, fy);
 299                             }
 300                         }
 301                     }
 302                 }
 303                 break;
 304                 default : SetError(errIllegalParameter); break;
 305             }
 306         }
 307         PushDouble(fy);
 308     }
 309 }
 310
 311 ScMatrixRef ScInterpreter::GetNewMat(SCSIZE nC, SCSIZE nR)
 312 {
 313     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::GetNewMat" );
 314     ScMatrix* pMat = new ScMatrix( nC, nR);
 315     pMat->SetErrorInterpreter( this);
 316     SCSIZE nCols, nRows;
 317     pMat->GetDimensions( nCols, nRows);
 318     if ( nCols != nC || nRows != nR )
 319     {   // arbitray limit of elements exceeded
 320         SetError( errStackOverflow);
 321         pMat->Delete();
 322         pMat = NULL;
 323     }
 324     return pMat;
 325 }
 326
 327 ScInterpreter::VolatileType ScInterpreter::GetVolatileType() const
 328 {
 329     return meVolaileType;
 330 }
 331
 332 ScMatrixRef ScInterpreter::CreateMatrixFromDoubleRef( const FormulaToken* pToken,
 333         SCCOL nCol1, SCROW nRow1, SCTAB nTab1,
 334         SCCOL nCol2, SCROW nRow2, SCTAB nTab2 )
 335 {
 336     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::CreateMatrixFromDoubleRef" );
 337     ScMatrixRef pMat = NULL;
 338     if (nTab1 == nTab2 && !nGlobalError)
 339     {
 340         ScTokenMatrixMap::const_iterator aIter;
 341         if ( static_cast<SCSIZE>(nRow2 - nRow1 + 1) *
 342                 static_cast<SCSIZE>(nCol2 - nCol1 + 1) >
 343                 ScMatrix::GetElementsMax() )
 344             SetError(errStackOverflow);
 345         else if (pTokenMatrixMap && ((aIter = pTokenMatrixMap->find( pToken))
 346                     != pTokenMatrixMap->end()))
 347             pMat = static_cast<ScToken*>((*aIter).second.get())->GetMatrix();
 348         else
 349         {
 350             SCSIZE nMatCols = static_cast<SCSIZE>(nCol2 - nCol1 + 1);
 351             SCSIZE nMatRows = static_cast<SCSIZE>(nRow2 - nRow1 + 1);
 352             pMat = GetNewMat( nMatCols, nMatRows);
 353             if (pMat && !nGlobalError)
 354             {
 355                 // Set position where the next entry is expected.
 356                 SCROW nNextRow = nRow1;
 357                 SCCOL nNextCol = nCol1;
 358                 // Set last position as if there was a previous entry.
 359                 SCROW nThisRow = nRow2;
 360                 SCCOL nThisCol = nCol1 - 1;
 361                 ScCellIterator aCellIter( pDok, nCol1, nRow1, nTab1, nCol2,
 362                         nRow2, nTab2);
 363                 for (ScBaseCell* pCell = aCellIter.GetFirst(); pCell; pCell =
 364                         aCellIter.GetNext())
 365                 {
 366                     nThisCol = aCellIter.GetCol();
 367                     nThisRow = aCellIter.GetRow();
 368                     if (nThisCol != nNextCol || nThisRow != nNextRow)
 369                     {
 370                         // Fill empty between iterator's positions.
 371                         for ( ; nNextCol <= nThisCol; ++nNextCol)
 372                         {
 373                             SCSIZE nC = nNextCol - nCol1;
 374                             SCSIZE nMatStopRow = ((nNextCol < nThisCol) ?
 375                                     nMatRows : nThisRow - nRow1);
 376                             for (SCSIZE nR = nNextRow - nRow1; nR <
 377                                     nMatStopRow; ++nR)
 378                             {
 379                                 pMat->PutEmpty( nC, nR);
 380                             }
 381                             nNextRow = nRow1;
 382                         }
 383                     }
 384                     if (nThisRow == nRow2)
 385                     {
 386                         nNextCol = nThisCol + 1;
 387                         nNextRow = nRow1;
 388                     }
 389                     else
 390                     {
 391                         nNextCol = nThisCol;
 392                         nNextRow = nThisRow + 1;
 393                     }
 394                     if (HasCellEmptyData(pCell))
 395                     {
 396                         pMat->PutEmpty( static_cast<SCSIZE>(nThisCol-nCol1),
 397                                 static_cast<SCSIZE>(nThisRow-nRow1));
 398                     }
 399                     else if (HasCellValueData(pCell))
 400                     {
 401                         ScAddress aAdr( nThisCol, nThisRow, nTab1);
 402                         double fVal = GetCellValue( aAdr, pCell);
 403                         if ( nGlobalError )
 404                         {
 405                             fVal = CreateDoubleError( nGlobalError);
 406                             nGlobalError = 0;
 407                         }
 408                         pMat->PutDouble( fVal,
 409                                 static_cast<SCSIZE>(nThisCol-nCol1),
 410                                 static_cast<SCSIZE>(nThisRow-nRow1));
 411                     }
 412                     else
 413                     {
 414                         String aStr;
 415                         GetCellString( aStr, pCell);
 416                         if ( nGlobalError )
 417                         {
 418                             double fVal = CreateDoubleError( nGlobalError);
 419                             nGlobalError = 0;
 420                             pMat->PutDouble( fVal,
 421                                     static_cast<SCSIZE>(nThisCol-nCol1),
 422                                     static_cast<SCSIZE>(nThisRow-nRow1));
 423                         }
 424                         else
 425                             pMat->PutString( aStr,
 426                                     static_cast<SCSIZE>(nThisCol-nCol1),
 427                                     static_cast<SCSIZE>(nThisRow-nRow1));
 428                     }
 429                 }
 430                 // Fill empty if iterator's last position wasn't the end.
 431                 if (nThisCol != nCol2 || nThisRow != nRow2)
 432                 {
 433                     for ( ; nNextCol <= nCol2; ++nNextCol)
 434                     {
 435                         SCSIZE nC = nNextCol - nCol1;
 436                         for (SCSIZE nR = nNextRow - nRow1; nR < nMatRows; ++nR)
 437                         {
 438                             pMat->PutEmpty( nC, nR);
 439                         }
 440                         nNextRow = nRow1;
 441                     }
 442                 }
 443                 if (pTokenMatrixMap)
 444                     pTokenMatrixMap->insert( ScTokenMatrixMap::value_type(
 445                                 pToken, new ScMatrixToken( pMat)));
 446             }
 447         }
 448     }
 449     else                                // not a 2D matrix
 450         SetError(errIllegalParameter);
 451     return pMat;
 452 }
 453
 454
 455 ScMatrixRef ScInterpreter::GetMatrix()
 456 {
 457     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::GetMatrix" );
 458     ScMatrixRef pMat = NULL;
 459     switch (GetRawStackType())
 460     {
 461         case svSingleRef :
 462         {
 463             ScAddress aAdr;
 464             PopSingleRef( aAdr );
 465             pMat = GetNewMat(1, 1);
 466             if (pMat)
 467             {
 468                 ScBaseCell* pCell = GetCell( aAdr );
 469                 if (HasCellEmptyData(pCell))
 470                     pMat->PutEmpty( 0 );
 471                 else if (HasCellValueData(pCell))
 472                     pMat->PutDouble(GetCellValue(aAdr, pCell), 0);
 473                 else
 474                 {
 475                     String aStr;
 476                     GetCellString(aStr, pCell);
 477                     pMat->PutString(aStr, 0);
 478                 }
 479             }
 480         }
 481         break;
 482         case svDoubleRef:
 483         {
 484             SCCOL nCol1, nCol2;
 485             SCROW nRow1, nRow2;
 486             SCTAB nTab1, nTab2;
 487             const ScToken* p = sp ? static_cast<const ScToken*>(pStack[sp-1]) : NULL;
 488             PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
 489             pMat = CreateMatrixFromDoubleRef( p, nCol1, nRow1, nTab1,
 490                     nCol2, nRow2, nTab2);
 491         }
 492         break;
 493         case svMatrix:
 494             pMat = PopMatrix();
 495         break;
 496         case svError :
 497         case svMissing :
 498         case svDouble :
 499         {
 500             double fVal = GetDouble();
 501             pMat = GetNewMat( 1, 1);
 502             if ( pMat )
 503             {
 504                 if ( nGlobalError )
 505                 {
 506                     fVal = CreateDoubleError( nGlobalError);
 507                     nGlobalError = 0;
 508                 }
 509                 pMat->PutDouble( fVal, 0);
 510             }
 511         }
 512         break;
 513         case svString :
 514         {
 515             String aStr = GetString();
 516             pMat = GetNewMat( 1, 1);
 517             if ( pMat )
 518             {
 519                 if ( nGlobalError )
 520                 {
 521                     double fVal = CreateDoubleError( nGlobalError);
 522                     pMat->PutDouble( fVal, 0);
 523                     nGlobalError = 0;
 524                 }
 525                 else
 526                     pMat->PutString( aStr, 0);
 527             }
 528         }
 529         break;
 530         default:
 531             PopError();
 532             SetError( errIllegalArgument);
 533         break;
 534     }
 535     return pMat;
 536 }
 537
 538 void ScInterpreter::ScMatValue()
 539 {
 540     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMatValue" );
 541     if ( MustHaveParamCount( GetByte(), 3 ) )
 542     {
 543         // 0 to count-1
 544         SCSIZE nR = static_cast<SCSIZE>(::rtl::math::approxFloor(GetDouble()));
 545         SCSIZE nC = static_cast<SCSIZE>(::rtl::math::approxFloor(GetDouble()));
 546         switch (GetStackType())
 547         {
 548             case svSingleRef :
 549             {
 550                 ScAddress aAdr;
 551                 PopSingleRef( aAdr );
 552                 ScBaseCell* pCell = GetCell( aAdr );
 553                 if (pCell && pCell->GetCellType() == CELLTYPE_FORMULA)
 554                 {
 555                     USHORT nErrCode = ((ScFormulaCell*)pCell)->GetErrCode();
 556                     if (nErrCode != 0)
 557                         PushError( nErrCode);
 558                     else
 559                     {
 560                         const ScMatrix* pMat = ((ScFormulaCell*)pCell)->GetMatrix();
 561                         CalculateMatrixValue(pMat,nC,nR);
 562                     }
 563                 }
 564                 else
 565                     PushIllegalParameter();
 566             }
 567             break;
 568             case svDoubleRef :
 569             {
 570                 SCCOL nCol1;
 571                 SCROW nRow1;
 572                 SCTAB nTab1;
 573                 SCCOL nCol2;
 574                 SCROW nRow2;
 575                 SCTAB nTab2;
 576                 PopDoubleRef(nCol1, nRow1, nTab1, nCol2, nRow2, nTab2);
 577                 if (nCol2 - nCol1 >= static_cast<SCCOL>(nR) &&
 578                         nRow2 - nRow1 >= static_cast<SCROW>(nC) &&
 579                         nTab1 == nTab2)
 580                 {
 581                     ScAddress aAdr( sal::static_int_cast<SCCOL>( nCol1 + nR ),
 582                                     sal::static_int_cast<SCROW>( nRow1 + nC ), nTab1 );
 583                     ScBaseCell* pCell = GetCell( aAdr );
 584                     if (HasCellValueData(pCell))
 585                         PushDouble(GetCellValue( aAdr, pCell ));
 586                     else
 587                     {
 588                         String aStr;
 589                         GetCellString(aStr, pCell);
 590                         PushString(aStr);
 591                     }
 592                 }
 593                 else
 594                     PushNoValue();
 595             }
 596             break;
 597             case svMatrix:
 598             {
 599                 ScMatrixRef pMat = PopMatrix();
 600                 CalculateMatrixValue(pMat,nC,nR);
 601             }
 602             break;
 603             default:
 604                 PopError();
 605                 PushIllegalParameter();
 606             break;
 607         }
 608     }
 609 }
 610 void ScInterpreter::CalculateMatrixValue(const ScMatrix* pMat,SCSIZE nC,SCSIZE nR)
 611 {
 612     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::CalculateMatrixValue" );
 613     if (pMat)
 614     {
 615         SCSIZE nCl, nRw;
 616         pMat->GetDimensions(nCl, nRw);
 617         if (nC < nCl && nR < nRw)
 618         {
 619             ScMatValType nMatValType;
 620             const ScMatrixValue* pMatVal = pMat->Get( nC, nR,nMatValType);
 621             if (ScMatrix::IsNonValueType( nMatValType))
 622                 PushString( pMatVal->GetString() );
 623             else
 624                 PushDouble(pMatVal->fVal);
 625                 // also handles DoubleError
 626         }
 627         else
 628             PushNoValue();
 629     }
 630     else
 631         PushNoValue();
 632 }
 633
 634 void ScInterpreter::ScEMat()
 635 {
 636     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScEMat" );
 637     if ( MustHaveParamCount( GetByte(), 1 ) )
 638     {
 639         SCSIZE nDim = static_cast<SCSIZE>(::rtl::math::approxFloor(GetDouble()));
 640         if ( nDim * nDim > ScMatrix::GetElementsMax() || nDim == 0)
 641             PushIllegalArgument();
 642         else
 643         {
 644             ScMatrixRef pRMat = GetNewMat(nDim, nDim);
 645             if (pRMat)
 646             {
 647                 MEMat(pRMat, nDim);
 648                 PushMatrix(pRMat);
 649             }
 650             else
 651                 PushIllegalArgument();
 652         }
 653     }
 654 }
 655
 656 void ScInterpreter::MEMat(ScMatrix* mM, SCSIZE n)
 657 {
 658     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::MEMat" );
 659     mM->FillDouble(0.0, 0, 0, n-1, n-1);
 660     for (SCSIZE i = 0; i < n; i++)
 661         mM->PutDouble(1.0, i, i);
 662 }
 663
 664 void ScInterpreter::MFastMult(ScMatrix* pA, ScMatrix* pB, ScMatrix* pR,
 665                               SCSIZE n, SCSIZE m, SCSIZE l)
 666         // Multipliziert n x m Mat a mit m x l Mat b nach Mat r
 667 {
 668     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::MFastMult" );
 669     double sum;
 670     for (SCSIZE i = 0; i < n; i++)
 671     {
 672         for (SCSIZE j = 0; j < l; j++)
 673         {
 674             sum = 0.0;
 675             for (SCSIZE k = 0; k < m; k++)
 676                 sum += pA->GetDouble(i,k)*pB->GetDouble(k,j);
 677             pR->PutDouble(sum, i, j);
 678         }
 679     }
 680 }
 681
 682
 683 /* Matrix LUP decomposition according to the pseudocode of "Introduction to
 684  * Algorithms" by Cormen, Leiserson, Rivest, Stein.
 685  *
 686  * Added scaling for numeric stability.
 687  *
 688  * Given an n x n nonsingular matrix A, find a permutation matrix P, a unit
 689  * lower-triangular matrix L, and an upper-triangular matrix U such that PA=LU.
 690  * Compute L and U "in place" in the matrix A, the original content is
 691  * destroyed. Note that the diagonal elements of the U triangular matrix
 692  * replace the diagonal elements of the L-unit matrix (that are each ==1). The
 693  * permutation matrix P is an array, where P[i]=j means that the i-th row of P
 694  * contains a 1 in column j. Additionally keep track of the number of
 695  * permutations (row exchanges).
 696  *
 697  * Returns 0 if a singular matrix is encountered, else +1 if an even number of
 698  * permutations occured, or -1 if odd, which is the sign of the determinant.
 699  * This may be used to calculate the determinant by multiplying the sign with
 700  * the product of the diagonal elements of the LU matrix.
 701  */
 702 static int lcl_LUP_decompose( ScMatrix* mA, const SCSIZE n,
 703         ::std::vector< SCSIZE> & P )
 704 {
 705     int nSign = 1;
 706     // Find scale of each row.
 707     ::std::vector< double> aScale(n);
 708     for (SCSIZE i=0; i < n; ++i)
 709     {
 710         double fMax = 0.0;
 711         for (SCSIZE j=0; j < n; ++j)
 712         {
 713             double fTmp = fabs( mA->GetDouble( j, i));
 714             if (fMax < fTmp)
 715                 fMax = fTmp;
 716         }
 717         if (fMax == 0.0)
 718             return 0;       // singular matrix
 719         aScale[i] = 1.0 / fMax;
 720     }
 721     // Represent identity permutation, P[i]=i
 722     for (SCSIZE i=0; i < n; ++i)
 723         P[i] = i;
 724     // "Recursion" on the diagonale.
 725     SCSIZE l = n - 1;
 726     for (SCSIZE k=0; k < l; ++k)
 727     {
 728         // Implicit pivoting. With the scale found for a row, compare values of
 729         // a column and pick largest.
 730         double fMax = 0.0;
 731         double fScale = aScale[k];
 732         SCSIZE kp = k;
 733         for (SCSIZE i = k; i < n; ++i)
 734         {
 735             double fTmp = fScale * fabs( mA->GetDouble( k, i));
 736             if (fMax < fTmp)
 737             {
 738                 fMax = fTmp;
 739                 kp = i;
 740             }
 741         }
 742         if (fMax == 0.0)
 743             return 0;       // singular matrix
 744         // Swap rows. The pivot element will be at mA[k,kp] (row,col notation)
 745         if (k != kp)
 746         {
 747             // permutations
 748             SCSIZE nTmp = P[k];
 749             P[k]        = P[kp];
 750             P[kp]       = nTmp;
 751             nSign       = -nSign;
 752             // scales
 753             double fTmp = aScale[k];
 754             aScale[k]   = aScale[kp];
 755             aScale[kp]  = fTmp;
 756             // elements
 757             for (SCSIZE i=0; i < n; ++i)
 758             {
 759                 double fMatTmp = mA->GetDouble( i, k);
 760                 mA->PutDouble( mA->GetDouble( i, kp), i, k);
 761                 mA->PutDouble( fMatTmp, i, kp);
 762             }
 763         }
 764         // Compute Schur complement.
 765         for (SCSIZE i = k+1; i < n; ++i)
 766         {
 767             double fTmp = mA->GetDouble( k, i) / mA->GetDouble( k, k);
 768             mA->PutDouble( fTmp, k, i);
 769             for (SCSIZE j = k+1; j < n; ++j)
 770                 mA->PutDouble( mA->GetDouble( j, i) - fTmp * mA->GetDouble( j,
 771                             k), j, i);
 772         }
 773     }
 774 #if OSL_DEBUG_LEVEL > 1
 775     fprintf( stderr, "\n%s\n", "lcl_LUP_decompose(): LU");
 776     for (SCSIZE i=0; i < n; ++i)
 777     {
 778         for (SCSIZE j=0; j < n; ++j)
 779             fprintf( stderr, "%8.2g  ", mA->GetDouble( j, i));
 780         fprintf( stderr, "\n%s\n", "");
 781     }
 782     fprintf( stderr, "\n%s\n", "lcl_LUP_decompose(): P");
 783     for (SCSIZE j=0; j < n; ++j)
 784         fprintf( stderr, "%5u ", (unsigned)P[j]);
 785     fprintf( stderr, "\n%s\n", "");
 786 #endif
 787     return nSign;
 788 }
 789
 790
 791 /* Solve a LUP decomposed equation Ax=b. LU is a combined matrix of L and U
 792  * triangulars and P the permutation vector as obtained from
 793  * lcl_LUP_decompose(). B is the right-hand side input vector, X is used to
 794  * return the solution vector.
 795  */
 796 static void lcl_LUP_solve( const ScMatrix* mLU, const SCSIZE n,
 797         const ::std::vector< SCSIZE> & P, const ::std::vector< double> & B,
 798         ::std::vector< double> & X )
 799 {
 800     SCSIZE nFirst = SCSIZE_MAX;
 801     // Ax=b => PAx=Pb, with decomposition LUx=Pb.
 802     // Define y=Ux and solve for y in Ly=Pb using forward substitution.
 803     for (SCSIZE i=0; i < n; ++i)
 804     {
 805         double fSum = B[P[i]];
 806         // Matrix inversion comes with a lot of zeros in the B vectors, we
 807         // don't have to do all the computing with results multiplied by zero.
 808         // Until then, simply lookout for the position of the first nonzero
 809         // value.
 810         if (nFirst != SCSIZE_MAX)
 811         {
 812             for (SCSIZE j = nFirst; j < i; ++j)
 813                 fSum -= mLU->GetDouble( j, i) * X[j];   // X[j] === y[j]
 814         }
 815         else if (fSum)
 816             nFirst = i;
 817         X[i] = fSum;                                    // X[i] === y[i]
 818     }
 819     // Solve for x in Ux=y using back substitution.
 820     for (SCSIZE i = n; i--; )
 821     {
 822         double fSum = X[i];                             // X[i] === y[i]
 823         for (SCSIZE j = i+1; j < n; ++j)
 824             fSum -= mLU->GetDouble( j, i) * X[j];       // X[j] === x[j]
 825         X[i] = fSum / mLU->GetDouble( i, i);            // X[i] === x[i]
 826     }
 827 #if OSL_DEBUG_LEVEL >1
 828     fprintf( stderr, "\n%s\n", "lcl_LUP_solve():");
 829     for (SCSIZE i=0; i < n; ++i)
 830         fprintf( stderr, "%8.2g  ", X[i]);
 831     fprintf( stderr, "%s\n", "");
 832 #endif
 833 }
 834
 835
 836 void ScInterpreter::ScMatDet()
 837 {
 838     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMatDet" );
 839     if ( MustHaveParamCount( GetByte(), 1 ) )
 840     {
 841         ScMatrixRef pMat = GetMatrix();
 842         if (!pMat)
 843         {
 844             PushIllegalParameter();
 845             return;
 846         }
 847         if ( !pMat->IsNumeric() )
 848         {
 849             PushNoValue();
 850             return;
 851         }
 852         SCSIZE nC, nR;
 853         pMat->GetDimensions(nC, nR);
 854         if ( nC != nR || nC == 0 || (ULONG) nC * nC > ScMatrix::GetElementsMax() )
 855             PushIllegalArgument();
 856         else
 857         {
 858             // LUP decomposition is done inplace, use copy.
 859             ScMatrixRef xLU = pMat->Clone();
 860             if (!xLU)
 861                 PushError( errCodeOverflow);
 862             else
 863             {
 864                 ::std::vector< SCSIZE> P(nR);
 865                 int nDetSign = lcl_LUP_decompose( xLU, nR, P);
 866                 if (!nDetSign)
 867                     PushInt(0);     // singular matrix
 868                 else
 869                 {
 870                     // In an LU matrix the determinant is simply the product of
 871                     // all diagonal elements.
 872                     double fDet = nDetSign;
 873                     ScMatrix* pLU = xLU;
 874                     for (SCSIZE i=0; i < nR; ++i)
 875                         fDet *= pLU->GetDouble( i, i);
 876                     PushDouble( fDet);
 877                 }
 878             }
 879         }
 880     }
 881 }
 882
 883 void ScInterpreter::ScMatInv()
 884 {
 885     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMatInv" );
 886     if ( MustHaveParamCount( GetByte(), 1 ) )
 887     {
 888         ScMatrixRef pMat = GetMatrix();
 889         if (!pMat)
 890         {
 891             PushIllegalParameter();
 892             return;
 893         }
 894         if ( !pMat->IsNumeric() )
 895         {
 896             PushNoValue();
 897             return;
 898         }
 899         SCSIZE nC, nR;
 900         pMat->GetDimensions(nC, nR);
 901         if ( nC != nR || nC == 0 || (ULONG) nC * nC > ScMatrix::GetElementsMax() )
 902             PushIllegalArgument();
 903         else
 904         {
 905             // LUP decomposition is done inplace, use copy.
 906             ScMatrixRef xLU = pMat->Clone();
 907             // The result matrix.
 908             ScMatrixRef xY = GetNewMat( nR, nR);
 909             if (!xLU || !xY)
 910                 PushError( errCodeOverflow);
 911             else
 912             {
 913                 ::std::vector< SCSIZE> P(nR);
 914                 int nDetSign = lcl_LUP_decompose( xLU, nR, P);
 915                 if (!nDetSign)
 916                     PushIllegalArgument();
 917                 else
 918                 {
 919                     // Solve equation for each column.
 920                     ScMatrix* pY = xY;
 921                     ::std::vector< double> B(nR);
 922                     ::std::vector< double> X(nR);
 923                     for (SCSIZE j=0; j < nR; ++j)
 924                     {
 925                         for (SCSIZE i=0; i < nR; ++i)
 926                             B[i] = 0.0;
 927                         B[j] = 1.0;
 928                         lcl_LUP_solve( xLU, nR, P, B, X);
 929                         for (SCSIZE i=0; i < nR; ++i)
 930                             pY->PutDouble( X[i], j, i);
 931                     }
 932 #if 0
 933                     /* Possible checks for ill-condition:
 934                      * 1. Scale matrix, invert scaled matrix. If there are
 935                      *    elements of the inverted matrix that are several
 936                      *    orders of magnitude greater than 1 =>
 937                      *    ill-conditioned.
 938                      *    Just how much is "several orders"?
 939                      * 2. Invert the inverted matrix and assess whether the
 940                      *    result is sufficiently close to the original matrix.
 941                      *    If not => ill-conditioned.
 942                      *    Just what is sufficient?
 943                      * 3. Multiplying the inverse by the original matrix should
 944                      *    produce a result sufficiently close to the identity
 945                      *    matrix.
 946                      *    Just what is sufficient?
 947                      *
 948                      * The following is #3.
 949                      */
 950                     ScMatrixRef xR = GetNewMat( nR, nR);
 951                     if (xR)
 952                     {
 953                         ScMatrix* pR = xR;
 954                         MFastMult( pMat, pY, pR, nR, nR, nR);
 955 #if OSL_DEBUG_LEVEL > 1
 956                         fprintf( stderr, "\n%s\n", "ScMatInv(): mult-identity");
 957 #endif
 958                         for (SCSIZE i=0; i < nR; ++i)
 959                         {
 960                             for (SCSIZE j=0; j < nR; ++j)
 961                             {
 962                                 double fTmp = pR->GetDouble( j, i);
 963 #if OSL_DEBUG_LEVEL > 1
 964                                 fprintf( stderr, "%8.2g  ", fTmp);
 965 #endif
 966                                 if (fabs( fTmp - (i == j)) > fInvEpsilon)
 967                                     SetError( errIllegalArgument);
 968                             }
 969 #if OSL_DEBUG_LEVEL > 1
 970                         fprintf( stderr, "\n%s\n", "");
 971 #endif
 972                         }
 973                     }
 974 #endif
 975                     if (nGlobalError)
 976                         PushError( nGlobalError);
 977                     else
 978                         PushMatrix( pY);
 979                 }
 980             }
 981         }
 982     }
 983 }
 984
 985 void ScInterpreter::ScMatMult()
 986 {
 987     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMatMult" );
 988     if ( MustHaveParamCount( GetByte(), 2 ) )
 989     {
 990         ScMatrixRef pMat2 = GetMatrix();
 991         ScMatrixRef pMat1 = GetMatrix();
 992         ScMatrixRef pRMat;
 993         if (pMat1 && pMat2)
 994         {
 995             if ( pMat1->IsNumeric() && pMat2->IsNumeric() )
 996             {
 997                 SCSIZE nC1, nC2;
 998                 SCSIZE nR1, nR2;
 999                 pMat1->GetDimensions(nC1, nR1);
1000                 pMat2->GetDimensions(nC2, nR2);
1001                 if (nC1 != nR2)
1002                     PushIllegalArgument();
1003                 else
1004                 {
1005                     pRMat = GetNewMat(nC2, nR1);
1006                     if (pRMat)
1007                     {
1008                         double sum;
1009                         for (SCSIZE i = 0; i < nR1; i++)
1010                         {
1011                             for (SCSIZE j = 0; j < nC2; j++)
1012                             {
1013                                 sum = 0.0;
1014                                 for (SCSIZE k = 0; k < nC1; k++)
1015                                 {
1016                                     sum += pMat1->GetDouble(k,i)*pMat2->GetDouble(j,k);
1017                                 }
1018                                 pRMat->PutDouble(sum, j, i);
1019                             }
1020                         }
1021                         PushMatrix(pRMat);
1022                     }
1023                     else
1024                         PushIllegalArgument();
1025                 }
1026             }
1027             else
1028                 PushNoValue();
1029         }
1030         else
1031             PushIllegalParameter();
1032     }
1033 }
1034
1035 void ScInterpreter::ScMatTrans()
1036 {
1037     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMatTrans" );
1038     if ( MustHaveParamCount( GetByte(), 1 ) )
1039     {
1040         ScMatrixRef pMat = GetMatrix();
1041         ScMatrixRef pRMat;
1042         if (pMat)
1043         {
1044             SCSIZE nC, nR;
1045             pMat->GetDimensions(nC, nR);
1046             pRMat = GetNewMat(nR, nC);
1047             if ( pRMat )
1048             {
1049                 pMat->MatTrans(*pRMat);
1050                 PushMatrix(pRMat);
1051             }
1052             else
1053                 PushIllegalArgument();
1054         }
1055         else
1056             PushIllegalParameter();
1057     }
1058 }
1059
1060
1061 /** Minimum extent of one result matrix dimension.
1062     For a row or column vector to be replicated the larger matrix dimension is
1063     returned, else the smaller dimension.
1064  */
1065 inline SCSIZE lcl_GetMinExtent( SCSIZE n1, SCSIZE n2 )
1066 {
1067     if (n1 == 1)
1068         return n2;
1069     else if (n2 == 1)
1070         return n1;
1071     else if (n1 < n2)
1072         return n1;
1073     else
1074         return n2;
1075 }
1076
1077 template<class _Function>
1078 ScMatrixRef lcl_MatrixCalculation(const _Function& _pOperation,ScMatrix* pMat1, ScMatrix* pMat2,ScInterpreter* _pIterpreter)
1079 {
1080     SCSIZE nC1, nC2, nMinC;
1081     SCSIZE nR1, nR2, nMinR;
1082     SCSIZE i, j;
1083     pMat1->GetDimensions(nC1, nR1);
1084     pMat2->GetDimensions(nC2, nR2);
1085     nMinC = lcl_GetMinExtent( nC1, nC2);
1086     nMinR = lcl_GetMinExtent( nR1, nR2);
1087     ScMatrixRef xResMat = _pIterpreter->GetNewMat(nMinC, nMinR);
1088     if (xResMat)
1089     {
1090         ScMatrix* pResMat = xResMat;
1091         for (i = 0; i < nMinC; i++)
1092         {
1093             for (j = 0; j < nMinR; j++)
1094             {
1095                 if (pMat1->IsValueOrEmpty(i,j) && pMat2->IsValueOrEmpty(i,j))
1096                 {
1097                     double d = _pOperation(pMat1->GetDouble(i,j),pMat2->GetDouble(i,j));
1098                     pResMat->PutDouble( d, i, j);
1099                 }
1100                 else
1101                     pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i, j);
1102             }
1103         }
1104     }
1105     return xResMat;
1106 }
1107
1108 ScMatrixRef ScInterpreter::MatConcat(ScMatrix* pMat1, ScMatrix* pMat2)
1109 {
1110     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::MatConcat" );
1111     SCSIZE nC1, nC2, nMinC;
1112     SCSIZE nR1, nR2, nMinR;
1113     SCSIZE i, j;
1114     pMat1->GetDimensions(nC1, nR1);
1115     pMat2->GetDimensions(nC2, nR2);
1116     nMinC = lcl_GetMinExtent( nC1, nC2);
1117     nMinR = lcl_GetMinExtent( nR1, nR2);
1118     ScMatrixRef xResMat = GetNewMat(nMinC, nMinR);
1119     if (xResMat)
1120     {
1121         ScMatrix* pResMat = xResMat;
1122         for (i = 0; i < nMinC; i++)
1123         {
1124             for (j = 0; j < nMinR; j++)
1125             {
1126                 USHORT nErr = pMat1->GetErrorIfNotString( i, j);
1127                 if (!nErr)
1128                     nErr = pMat2->GetErrorIfNotString( i, j);
1129                 if (nErr)
1130                     pResMat->PutError( nErr, i, j);
1131                 else
1132                 {
1133                     String aTmp( pMat1->GetString( *pFormatter, i, j));
1134                     aTmp += pMat2->GetString( *pFormatter, i, j);
1135                     pResMat->PutString( aTmp, i, j);
1136                 }
1137             }
1138         }
1139     }
1140     return xResMat;
1141 }
1142
1143
1144 // fuer DATE, TIME, DATETIME
1145 void lcl_GetDiffDateTimeFmtType( short& nFuncFmt, short nFmt1, short nFmt2 )
1146 {
1147     if ( nFmt1 != NUMBERFORMAT_UNDEFINED || nFmt2 != NUMBERFORMAT_UNDEFINED )
1148     {
1149         if ( nFmt1 == nFmt2 )
1150         {
1151             if ( nFmt1 == NUMBERFORMAT_TIME || nFmt1 == NUMBERFORMAT_DATETIME )
1152                 nFuncFmt = NUMBERFORMAT_TIME;   // Zeiten ergeben Zeit
1153             // else: nichts besonderes, Zahl (Datum - Datum := Tage)
1154         }
1155         else if ( nFmt1 == NUMBERFORMAT_UNDEFINED )
1156             nFuncFmt = nFmt2;   // z.B. Datum + Tage := Datum
1157         else if ( nFmt2 == NUMBERFORMAT_UNDEFINED )
1158             nFuncFmt = nFmt1;
1159         else
1160         {
1161             if ( nFmt1 == NUMBERFORMAT_DATE || nFmt2 == NUMBERFORMAT_DATE ||
1162                 nFmt1 == NUMBERFORMAT_DATETIME || nFmt2 == NUMBERFORMAT_DATETIME )
1163             {
1164                 if ( nFmt1 == NUMBERFORMAT_TIME || nFmt2 == NUMBERFORMAT_TIME )
1165                     nFuncFmt = NUMBERFORMAT_DATETIME;   // Datum + Zeit
1166             }
1167         }
1168     }
1169 }
1170
1171
1172 void ScInterpreter::ScAdd()
1173 {
1174     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScAdd" );
1175     CalculateAddSub(FALSE);
1176 }
1177 void ScInterpreter::CalculateAddSub(BOOL _bSub)
1178 {
1179     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::CalculateAddSub" );
1180     ScMatrixRef pMat1 = NULL;
1181     ScMatrixRef pMat2 = NULL;
1182     double fVal1 = 0.0, fVal2 = 0.0;
1183     short nFmt1, nFmt2;
1184     nFmt1 = nFmt2 = NUMBERFORMAT_UNDEFINED;
1185     short nFmtCurrencyType = nCurFmtType;
1186     ULONG nFmtCurrencyIndex = nCurFmtIndex;
1187     short nFmtPercentType = nCurFmtType;
1188     if ( GetStackType() == svMatrix )
1189         pMat2 = GetMatrix();
1190     else
1191     {
1192         fVal2 = GetDouble();
1193         switch ( nCurFmtType )
1194         {
1195             case NUMBERFORMAT_DATE :
1196             case NUMBERFORMAT_TIME :
1197             case NUMBERFORMAT_DATETIME :
1198                 nFmt2 = nCurFmtType;
1199             break;
1200             case NUMBERFORMAT_CURRENCY :
1201                 nFmtCurrencyType = nCurFmtType;
1202                 nFmtCurrencyIndex = nCurFmtIndex;
1203             break;
1204             case NUMBERFORMAT_PERCENT :
1205                 nFmtPercentType = NUMBERFORMAT_PERCENT;
1206             break;
1207         }
1208     }
1209     if ( GetStackType() == svMatrix )
1210         pMat1 = GetMatrix();
1211     else
1212     {
1213         fVal1 = GetDouble();
1214         switch ( nCurFmtType )
1215         {
1216             case NUMBERFORMAT_DATE :
1217             case NUMBERFORMAT_TIME :
1218             case NUMBERFORMAT_DATETIME :
1219                 nFmt1 = nCurFmtType;
1220             break;
1221             case NUMBERFORMAT_CURRENCY :
1222                 nFmtCurrencyType = nCurFmtType;
1223                 nFmtCurrencyIndex = nCurFmtIndex;
1224             break;
1225             case NUMBERFORMAT_PERCENT :
1226                 nFmtPercentType = NUMBERFORMAT_PERCENT;
1227             break;
1228         }
1229     }
1230     if (pMat1 && pMat2)
1231     {
1232         ScMatrixRef pResMat;
1233         if ( _bSub )
1234         {
1235             MatrixSub aSub;
1236             pResMat = lcl_MatrixCalculation(aSub ,pMat1, pMat2,this);
1237         }
1238         else
1239         {
1240             MatrixAdd aAdd;
1241             pResMat = lcl_MatrixCalculation(aAdd ,pMat1, pMat2,this);
1242         }
1243
1244         if (!pResMat)
1245             PushNoValue();
1246         else
1247             PushMatrix(pResMat);
1248     }
1249     else if (pMat1 || pMat2)
1250     {
1251         double fVal;
1252         BOOL bFlag;
1253         ScMatrixRef pMat = pMat1;
1254         if (!pMat)
1255         {
1256             fVal = fVal1;
1257             pMat = pMat2;
1258             bFlag = TRUE;           // double - Matrix
1259         }
1260         else
1261         {
1262             fVal = fVal2;
1263             bFlag = FALSE;          // Matrix - double
1264         }
1265         SCSIZE nC, nR;
1266         pMat->GetDimensions(nC, nR);
1267         ScMatrixRef pResMat = GetNewMat(nC, nR);
1268         if (pResMat)
1269         {
1270             SCSIZE nCount = nC * nR;
1271             if (bFlag || !_bSub )
1272             {
1273                 for ( SCSIZE i = 0; i < nCount; i++ )
1274                 {
1275                     if (pMat->IsValue(i))
1276                         pResMat->PutDouble( _bSub ? ::rtl::math::approxSub( fVal, pMat->GetDouble(i)) : ::rtl::math::approxAdd( pMat->GetDouble(i), fVal), i);
1277                     else
1278                         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i);
1279                 } // for ( SCSIZE i = 0; i < nCount; i++ )
1280             } // if (bFlag || !_bSub )
1281             else
1282             {
1283                 for ( SCSIZE i = 0; i < nCount; i++ )
1284                 {   if (pMat->IsValue(i))
1285                         pResMat->PutDouble( ::rtl::math::approxSub( pMat->GetDouble(i), fVal), i);
1286                     else
1287                         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i);
1288                 } // for ( SCSIZE i = 0; i < nCount; i++ )
1289             }
1290             PushMatrix(pResMat);
1291         }
1292         else
1293             PushIllegalArgument();
1294     }
1295     else if ( _bSub )
1296         PushDouble( ::rtl::math::approxSub( fVal1, fVal2 ) );
1297     else
1298         PushDouble( ::rtl::math::approxAdd( fVal1, fVal2 ) );
1299     if ( nFmtCurrencyType == NUMBERFORMAT_CURRENCY )
1300     {
1301         nFuncFmtType = nFmtCurrencyType;
1302         nFuncFmtIndex = nFmtCurrencyIndex;
1303     }
1304     else
1305     {
1306         lcl_GetDiffDateTimeFmtType( nFuncFmtType, nFmt1, nFmt2 );
1307         if ( nFmtPercentType == NUMBERFORMAT_PERCENT && nFuncFmtType == NUMBERFORMAT_NUMBER )
1308             nFuncFmtType = NUMBERFORMAT_PERCENT;
1309     }
1310 }
1311
1312 void ScInterpreter::ScAmpersand()
1313 {
1314     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScAmpersand" );
1315     ScMatrixRef pMat1 = NULL;
1316     ScMatrixRef pMat2 = NULL;
1317     String sStr1, sStr2;
1318     if ( GetStackType() == svMatrix )
1319         pMat2 = GetMatrix();
1320     else
1321         sStr2 = GetString();
1322     if ( GetStackType() == svMatrix )
1323         pMat1 = GetMatrix();
1324     else
1325         sStr1 = GetString();
1326     if (pMat1 && pMat2)
1327     {
1328         ScMatrixRef pResMat = MatConcat(pMat1, pMat2);
1329         if (!pResMat)
1330             PushNoValue();
1331         else
1332             PushMatrix(pResMat);
1333     }
1334     else if (pMat1 || pMat2)
1335     {
1336         String sStr;
1337         BOOL bFlag;
1338         ScMatrixRef pMat = pMat1;
1339         if (!pMat)
1340         {
1341             sStr = sStr1;
1342             pMat = pMat2;
1343             bFlag = TRUE;           // double - Matrix
1344         }
1345         else
1346         {
1347             sStr = sStr2;
1348             bFlag = FALSE;          // Matrix - double
1349         }
1350         SCSIZE nC, nR;
1351         pMat->GetDimensions(nC, nR);
1352         ScMatrixRef pResMat = GetNewMat(nC, nR);
1353         if (pResMat)
1354         {
1355             SCSIZE nCount = nC * nR;
1356             if (nGlobalError)
1357             {
1358                 for ( SCSIZE i = 0; i < nCount; i++ )
1359                     pResMat->PutError( nGlobalError, i);
1360             }
1361             else if (bFlag)
1362             {
1363                 for ( SCSIZE i = 0; i < nCount; i++ )
1364                 {
1365                     USHORT nErr = pMat->GetErrorIfNotString( i);
1366                     if (nErr)
1367                         pResMat->PutError( nErr, i);
1368                     else
1369                     {
1370                         String aTmp( sStr);
1371                         aTmp += pMat->GetString( *pFormatter, i);
1372                         pResMat->PutString( aTmp, i);
1373                     }
1374                 }
1375             }
1376             else
1377             {
1378                 for ( SCSIZE i = 0; i < nCount; i++ )
1379                 {
1380                     USHORT nErr = pMat->GetErrorIfNotString( i);
1381                     if (nErr)
1382                         pResMat->PutError( nErr, i);
1383                     else
1384                     {
1385                         String aTmp( pMat->GetString( *pFormatter, i));
1386                         aTmp += sStr;
1387                         pResMat->PutString( aTmp, i);
1388                     }
1389                 }
1390             }
1391             PushMatrix(pResMat);
1392         }
1393         else
1394             PushIllegalArgument();
1395     }
1396     else
1397     {
1398         if ( CheckStringResultLen( sStr1, sStr2 ) )
1399             sStr1 += sStr2;
1400         PushString(sStr1);
1401     }
1402 }
1403
1404 void ScInterpreter::ScSub()
1405 {
1406     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScSub" );
1407     CalculateAddSub(TRUE);
1408 }
1409
1410 void ScInterpreter::ScMul()
1411 {
1412     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMul" );
1413     ScMatrixRef pMat1 = NULL;
1414     ScMatrixRef pMat2 = NULL;
1415     double fVal1 = 0.0, fVal2 = 0.0;
1416     short nFmtCurrencyType = nCurFmtType;
1417     ULONG nFmtCurrencyIndex = nCurFmtIndex;
1418     if ( GetStackType() == svMatrix )
1419         pMat2 = GetMatrix();
1420     else
1421     {
1422         fVal2 = GetDouble();
1423         switch ( nCurFmtType )
1424         {
1425             case NUMBERFORMAT_CURRENCY :
1426                 nFmtCurrencyType = nCurFmtType;
1427                 nFmtCurrencyIndex = nCurFmtIndex;
1428             break;
1429         }
1430     }
1431     if ( GetStackType() == svMatrix )
1432         pMat1 = GetMatrix();
1433     else
1434     {
1435         fVal1 = GetDouble();
1436         switch ( nCurFmtType )
1437         {
1438             case NUMBERFORMAT_CURRENCY :
1439                 nFmtCurrencyType = nCurFmtType;
1440                 nFmtCurrencyIndex = nCurFmtIndex;
1441             break;
1442         }
1443     }
1444     if (pMat1 && pMat2)
1445     {
1446         MatrixMul aMul;
1447         ScMatrixRef pResMat = lcl_MatrixCalculation(aMul,pMat1, pMat2,this);
1448         if (!pResMat)
1449             PushNoValue();
1450         else
1451             PushMatrix(pResMat);
1452     }
1453     else if (pMat1 || pMat2)
1454     {
1455         double fVal;
1456         ScMatrixRef pMat = pMat1;
1457         if (!pMat)
1458         {
1459             fVal = fVal1;
1460             pMat = pMat2;
1461         }
1462         else
1463             fVal = fVal2;
1464         SCSIZE nC, nR;
1465         pMat->GetDimensions(nC, nR);
1466         ScMatrixRef pResMat = GetNewMat(nC, nR);
1467         if (pResMat)
1468         {
1469             SCSIZE nCount = nC * nR;
1470             for ( SCSIZE i = 0; i < nCount; i++ )
1471                 if (pMat->IsValue(i))
1472                     pResMat->PutDouble(pMat->GetDouble(i)*fVal, i);
1473                 else
1474                     pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i);
1475             PushMatrix(pResMat);
1476         }
1477         else
1478             PushIllegalArgument();
1479     }
1480     else
1481         PushDouble(fVal1 * fVal2);
1482     if ( nFmtCurrencyType == NUMBERFORMAT_CURRENCY )
1483     {
1484         nFuncFmtType = nFmtCurrencyType;
1485         nFuncFmtIndex = nFmtCurrencyIndex;
1486     }
1487 }
1488
1489 void ScInterpreter::ScDiv()
1490 {
1491     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScDiv" );
1492     ScMatrixRef pMat1 = NULL;
1493     ScMatrixRef pMat2 = NULL;
1494     double fVal1 = 0.0, fVal2 = 0.0;
1495     short nFmtCurrencyType = nCurFmtType;
1496     ULONG nFmtCurrencyIndex = nCurFmtIndex;
1497     short nFmtCurrencyType2 = NUMBERFORMAT_UNDEFINED;
1498     if ( GetStackType() == svMatrix )
1499         pMat2 = GetMatrix();
1500     else
1501     {
1502         fVal2 = GetDouble();
1503         // hier kein Currency uebernehmen, 123kg/456DM sind nicht DM
1504         nFmtCurrencyType2 = nCurFmtType;
1505     }
1506     if ( GetStackType() == svMatrix )
1507         pMat1 = GetMatrix();
1508     else
1509     {
1510         fVal1 = GetDouble();
1511         switch ( nCurFmtType )
1512         {
1513             case NUMBERFORMAT_CURRENCY :
1514                 nFmtCurrencyType = nCurFmtType;
1515                 nFmtCurrencyIndex = nCurFmtIndex;
1516             break;
1517         }
1518     }
1519     if (pMat1 && pMat2)
1520     {
1521         MatrixDiv aDiv;
1522         ScMatrixRef pResMat = lcl_MatrixCalculation(aDiv,pMat1, pMat2,this);
1523         if (!pResMat)
1524             PushNoValue();
1525         else
1526             PushMatrix(pResMat);
1527     }
1528     else if (pMat1 || pMat2)
1529     {
1530         double fVal;
1531         BOOL bFlag;
1532         ScMatrixRef pMat = pMat1;
1533         if (!pMat)
1534         {
1535             fVal = fVal1;
1536             pMat = pMat2;
1537             bFlag = TRUE;           // double - Matrix
1538         }
1539         else
1540         {
1541             fVal = fVal2;
1542             bFlag = FALSE;          // Matrix - double
1543         }
1544         SCSIZE nC, nR;
1545         pMat->GetDimensions(nC, nR);
1546         ScMatrixRef pResMat = GetNewMat(nC, nR);
1547         if (pResMat)
1548         {
1549             SCSIZE nCount = nC * nR;
1550             if (bFlag)
1551             {   for ( SCSIZE i = 0; i < nCount; i++ )
1552                     if (pMat->IsValue(i))
1553                         pResMat->PutDouble( div( fVal, pMat->GetDouble(i)), i);
1554                     else
1555                         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i);
1556             }
1557             else
1558             {   for ( SCSIZE i = 0; i < nCount; i++ )
1559                     if (pMat->IsValue(i))
1560                         pResMat->PutDouble( div( pMat->GetDouble(i), fVal), i);
1561                     else
1562                         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i);
1563             }
1564             PushMatrix(pResMat);
1565         }
1566         else
1567             PushIllegalArgument();
1568     }
1569     else
1570     {
1571         PushDouble( div( fVal1, fVal2) );
1572     }
1573     if ( nFmtCurrencyType == NUMBERFORMAT_CURRENCY && nFmtCurrencyType2 != NUMBERFORMAT_CURRENCY )
1574     {   // auch DM/DM ist nicht DM bzw. DEM/EUR nicht DEM
1575         nFuncFmtType = nFmtCurrencyType;
1576         nFuncFmtIndex = nFmtCurrencyIndex;
1577     }
1578 }
1579
1580 void ScInterpreter::ScPower()
1581 {
1582     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScPower" );
1583     if ( MustHaveParamCount( GetByte(), 2 ) )
1584         ScPow();
1585 }
1586
1587 void ScInterpreter::ScPow()
1588 {
1589     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScPow" );
1590     ScMatrixRef pMat1 = NULL;
1591     ScMatrixRef pMat2 = NULL;
1592     double fVal1 = 0.0, fVal2 = 0.0;
1593     if ( GetStackType() == svMatrix )
1594         pMat2 = GetMatrix();
1595     else
1596         fVal2 = GetDouble();
1597     if ( GetStackType() == svMatrix )
1598         pMat1 = GetMatrix();
1599     else
1600         fVal1 = GetDouble();
1601     if (pMat1 && pMat2)
1602     {
1603         MatrixPow aPow;
1604         ScMatrixRef pResMat = lcl_MatrixCalculation(aPow,pMat1, pMat2,this);
1605         if (!pResMat)
1606             PushNoValue();
1607         else
1608             PushMatrix(pResMat);
1609     }
1610     else if (pMat1 || pMat2)
1611     {
1612         double fVal;
1613         BOOL bFlag;
1614         ScMatrixRef pMat = pMat1;
1615         if (!pMat)
1616         {
1617             fVal = fVal1;
1618             pMat = pMat2;
1619             bFlag = TRUE;           // double - Matrix
1620         }
1621         else
1622         {
1623             fVal = fVal2;
1624             bFlag = FALSE;          // Matrix - double
1625         }
1626         SCSIZE nC, nR;
1627         pMat->GetDimensions(nC, nR);
1628         ScMatrixRef pResMat = GetNewMat(nC, nR);
1629         if (pResMat)
1630         {
1631             SCSIZE nCount = nC * nR;
1632             if (bFlag)
1633             {   for ( SCSIZE i = 0; i < nCount; i++ )
1634                     if (pMat->IsValue(i))
1635                         pResMat->PutDouble(pow(fVal,pMat->GetDouble(i)), i);
1636                     else
1637                         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i);
1638             }
1639             else
1640             {   for ( SCSIZE i = 0; i < nCount; i++ )
1641                     if (pMat->IsValue(i))
1642                         pResMat->PutDouble(pow(pMat->GetDouble(i),fVal), i);
1643                     else
1644                         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i);
1645             }
1646             PushMatrix(pResMat);
1647         }
1648         else
1649             PushIllegalArgument();
1650     }
1651     else
1652         PushDouble(pow(fVal1,fVal2));
1653 }
1654
1655 void ScInterpreter::ScSumProduct()
1656 {
1657     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScSumProduct" );
1658     BYTE nParamCount = GetByte();
1659     if ( !MustHaveParamCount( nParamCount, 1, 30 ) )
1660         return;
1661
1662     ScMatrixRef pMat1 = NULL;
1663     ScMatrixRef pMat2 = NULL;
1664     ScMatrixRef pMat  = NULL;
1665     pMat2 = GetMatrix();
1666     if (!pMat2)
1667     {
1668         PushIllegalParameter();
1669         return;
1670     }
1671     SCSIZE nC, nC1;
1672     SCSIZE nR, nR1;
1673     pMat2->GetDimensions(nC, nR);
1674     pMat = pMat2;
1675     MatrixMul aMul;
1676     for (USHORT i = 1; i < nParamCount; i++)
1677     {
1678         pMat1 = GetMatrix();
1679         if (!pMat1)
1680         {
1681             PushIllegalParameter();
1682             return;
1683         }
1684         pMat1->GetDimensions(nC1, nR1);
1685         if (nC1 != nC || nR1 != nR)
1686         {
1687             PushNoValue();
1688             return;
1689         }
1690         ScMatrixRef pResMat = lcl_MatrixCalculation(aMul,pMat1, pMat,this);
1691         if (!pResMat)
1692         {
1693             PushNoValue();
1694             return;
1695         }
1696         else
1697             pMat = pResMat;
1698     }
1699     double fSum = 0.0;
1700     SCSIZE nCount = pMat->GetElementCount();
1701     for (SCSIZE j = 0; j < nCount; j++)
1702     {
1703         if (!pMat->IsString(j))
1704             fSum += pMat->GetDouble(j);
1705     }
1706     PushDouble(fSum);
1707 }
1708
1709 void ScInterpreter::ScSumX2MY2()
1710 {
1711     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScSumX2MY2" );
1712     CalculateSumX2MY2SumX2DY2(FALSE);
1713 }
1714 void ScInterpreter::CalculateSumX2MY2SumX2DY2(BOOL _bSumX2DY2)
1715 {
1716     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::CalculateSumX2MY2SumX2DY2" );
1717     if ( !MustHaveParamCount( GetByte(), 2 ) )
1718         return;
1719
1720     ScMatrixRef pMat1 = NULL;
1721     ScMatrixRef pMat2 = NULL;
1722     SCSIZE i, j;
1723     pMat2 = GetMatrix();
1724     pMat1 = GetMatrix();
1725     if (!pMat2 || !pMat1)
1726     {
1727         PushIllegalParameter();
1728         return;
1729     }
1730     SCSIZE nC1, nC2;
1731     SCSIZE nR1, nR2;
1732     pMat2->GetDimensions(nC2, nR2);
1733     pMat1->GetDimensions(nC1, nR1);
1734     if (nC1 != nC2 || nR1 != nR2)
1735     {
1736         PushNoValue();
1737         return;
1738     }
1739     double fVal, fSum = 0.0;
1740     for (i = 0; i < nC1; i++)
1741         for (j = 0; j < nR1; j++)
1742             if (!pMat1->IsString(i,j) && !pMat2->IsString(i,j))
1743             {
1744                 fVal = pMat1->GetDouble(i,j);
1745                 fSum += fVal * fVal;
1746                 fVal = pMat2->GetDouble(i,j);
1747                 if ( _bSumX2DY2 )
1748                     fSum += fVal * fVal;
1749                 else
1750                     fSum -= fVal * fVal;
1751             }
1752     PushDouble(fSum);
1753 }
1754
1755 void ScInterpreter::ScSumX2DY2()
1756 {
1757     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScSumX2DY2" );
1758     CalculateSumX2MY2SumX2DY2(TRUE);
1759 }
1760
1761 void ScInterpreter::ScSumXMY2()
1762 {
1763     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScSumXMY2" );
1764     if ( !MustHaveParamCount( GetByte(), 2 ) )
1765         return;
1766
1767     ScMatrixRef pMat1 = NULL;
1768     ScMatrixRef pMat2 = NULL;
1769     pMat2 = GetMatrix();
1770     pMat1 = GetMatrix();
1771     if (!pMat2 || !pMat1)
1772     {
1773         PushIllegalParameter();
1774         return;
1775     }
1776     SCSIZE nC1, nC2;
1777     SCSIZE nR1, nR2;
1778     pMat2->GetDimensions(nC2, nR2);
1779     pMat1->GetDimensions(nC1, nR1);
1780     if (nC1 != nC2 || nR1 != nR2)
1781     {
1782         PushNoValue();
1783         return;
1784     } // if (nC1 != nC2 || nR1 != nR2)
1785     MatrixSub aSub;
1786     ScMatrixRef pResMat = lcl_MatrixCalculation(aSub,pMat1, pMat2,this);
1787     if (!pResMat)
1788     {
1789         PushNoValue();
1790     }
1791     else
1792     {
1793         double fVal, fSum = 0.0;
1794         SCSIZE nCount = pResMat->GetElementCount();
1795         for (SCSIZE i = 0; i < nCount; i++)
1796             if (!pResMat->IsString(i))
1797             {
1798                 fVal = pResMat->GetDouble(i);
1799                 fSum += fVal * fVal;
1800             }
1801         PushDouble(fSum);
1802     }
1803 }
1804
1805 void ScInterpreter::ScFrequency()
1806 {
1807     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScFrequency" );
1808     if ( !MustHaveParamCount( GetByte(), 2 ) )
1809         return;
1810
1811     vector<double>  aBinArray;
1812     vector<long>    aBinIndexOrder;
1813
1814     GetSortArray(1, aBinArray, &aBinIndexOrder);
1815     SCSIZE nBinSize = aBinArray.size();
1816     if (nGlobalError)
1817     {
1818         PushNoValue();
1819         return;
1820     }
1821
1822     vector<double>  aDataArray;
1823     GetSortArray(1, aDataArray);
1824     SCSIZE nDataSize = aDataArray.size();
1825
1826     if (aDataArray.empty() || nGlobalError)
1827     {
1828         PushNoValue();
1829         return;
1830     }
1831     ScMatrixRef pResMat = GetNewMat(1, nBinSize+1);
1832     if (!pResMat)
1833     {
1834         PushIllegalArgument();
1835         return;
1836     }
1837
1838     if (nBinSize != aBinIndexOrder.size())
1839     {
1840         PushIllegalArgument();
1841         return;
1842     }
1843
1844     SCSIZE j;
1845     SCSIZE i = 0;
1846     for (j = 0; j < nBinSize; ++j)
1847     {
1848         SCSIZE nCount = 0;
1849         while (i < nDataSize && aDataArray[i] <= aBinArray[j])
1850         {
1851             ++nCount;
1852             ++i;
1853         }
1854         pResMat->PutDouble(static_cast<double>(nCount), aBinIndexOrder[j]);
1855     }
1856     pResMat->PutDouble(static_cast<double>(nDataSize-i), j);
1857     PushMatrix(pResMat);
1858 }
1859
1860 BOOL ScInterpreter::RGetVariances( ScMatrix* pV, ScMatrix* pX,
1861         SCSIZE nC, SCSIZE nR, BOOL bSwapColRow, BOOL bZeroConstant )
1862 {   // multiple Regression: Varianzen der Koeffizienten
1863     // bSwapColRow==TRUE : Koeffizienten in Zeilen statt Spalten angeordnet
1864     SCSIZE i, j, k;
1865     double sum;
1866     ScMatrixRef pC = GetNewMat(nC, nC);
1867     if ( !pC )
1868         return FALSE;
1869     // X transformiert mit X multipziert, X'X Matrix
1870     if ( !bZeroConstant )
1871     {   // in der X-Designmatrix existiert ein gedachtes X0j==1
1872         if ( bSwapColRow )
1873         {
1874             for ( i=0; i<nC; i++ )
1875             {
1876                 for ( j=0; j<nC; j++ )
1877                 {
1878                     sum = 0.0;
1879                     for ( k=0; k<nR; k++ )
1880                     {
1881                         sum += (j==0 ? 1 : pX->GetDouble(k,j-1))
1882                             * (i==0 ? 1 : pX->GetDouble(k,i-1));
1883                     }
1884                     pC->PutDouble(sum, i, j);
1885                 }
1886             }
1887         }
1888         else
1889         {
1890             for ( i=0; i<nC; i++ )
1891             {
1892                 for ( j=0; j<nC; j++ )
1893                 {
1894                     sum = 0.0;
1895                     for ( k=0; k<nR; k++ )
1896                     {
1897                         sum += (j==0 ? 1 : pX->GetDouble(j-1,k))
1898                             * (i==0 ? 1 : pX->GetDouble(i-1,k));
1899                     }
1900                     pC->PutDouble(sum, i, j);
1901                 }
1902             }
1903         }
1904     }
1905     else
1906     {
1907         if ( bSwapColRow )
1908         {
1909             for ( i=0; i<nC; i++ )
1910             {
1911                 for ( j=0; j<nC; j++ )
1912                 {
1913                     sum = 0.0;
1914                     for ( k=0; k<nR; k++ )
1915                     {
1916                         sum += pX->GetDouble(k,j) * pX->GetDouble(k,i);
1917                     }
1918                     pC->PutDouble(sum, i, j);
1919                 }
1920             }
1921         }
1922         else
1923         {
1924             for ( i=0; i<nC; i++ )
1925             {
1926                 for ( j=0; j<nC; j++ )
1927                 {
1928                     sum = 0.0;
1929                     for ( k=0; k<nR; k++ )
1930                     {
1931                         sum += pX->GetDouble(j,k) * pX->GetDouble(i,k);
1932                     }
1933                     pC->PutDouble(sum, i, j);
1934                 }
1935             }
1936         }
1937     }
1938     // X'X Inverse
1939     BOOL bOk = TRUE;
1940     USHORT nErr = nGlobalError;
1941     PushMatrix(pC);
1942     BYTE nTmp = cPar;
1943     cPar = 1;
1944     ScMatInv();
1945     cPar = nTmp;
1946     if ( nGlobalError )
1947     {
1948         nGlobalError = nErr;
1949         bOk = FALSE;
1950     }
1951     else
1952     {
1953         // #i61216# ScMatInv no longer modifies the original matrix, so just calling Pop() doesn't work
1954         pC = PopMatrix();
1955         if ( pC.Is() )
1956         {
1957             // Varianzen auf der Diagonalen, andere sind Kovarianzen
1958             for (i = 0; i < nC; i++)
1959                 pV->PutDouble(pC->GetDouble(i, i), i);
1960         }
1961     }
1962     return bOk;
1963 }
1964 // -----------------------------------------------------------------------------
1965 void ScInterpreter::Calculate(ScMatrixRef& pResMat,ScMatrixRef& pE,ScMatrixRef& pQ,ScMatrixRef& pV,ScMatrixRef& pMatX,BOOL bConstant,SCSIZE N,SCSIZE M,BYTE nCase)
1966 {
1967     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::RGetVariances" );
1968     // pE[0]    := Sigma i=1...n (Yi)
1969     // pE[k]    := Sigma i=1...n (Xki*Yi)
1970     // pE[M+1]  := Sigma i=1...n (Yi**2)
1971     // pQ[0,M+1]:= B
1972     // pQ[k,M+1]:= Mk
1973     double fSQR, fSQT, fSQE;
1974     fSQT = pE->GetDouble(M+1)
1975         - pE->GetDouble(0) * pE->GetDouble(0) / (double)N;
1976     fSQR = pE->GetDouble(M+1);
1977     SCSIZE i, j;
1978     for (i = 0; i < M+1; i++)
1979         fSQR -= pQ->GetDouble(i, M+1) * pE->GetDouble(i);
1980     fSQE = fSQT-fSQR;
1981     // r2 (Bestimmtheitsmass, 0...1)
1982     if (fSQT == 0.0)
1983         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 2);
1984     else
1985         pResMat->PutDouble (fSQE/fSQT, 0, 2);
1986     // ssReg (Regressions-Quadratsumme)
1987     pResMat->PutDouble(fSQE, 0, 4);
1988     // ssResid (Residual-Quadratsumme, Summe der Abweichungsquadrate)
1989     pResMat->PutDouble(fSQR, 1, 4);
1990     for (i = 2; i < 5; i++)
1991         for (j = 2; j < M+1; j++)
1992             pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), j, i);
1993     if (bConstant)
1994     {
1995         if (N-M-1 == 0)
1996         {
1997             pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2);
1998             for (i = 0; i < M+1; i++)
1999                 pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i, 1);
2000         }
2001         else
2002         {
2003             double fSE2 = fSQR/(N-M-1);
2004             // sey (Standardfehler des Schaetzwertes y)
2005             pResMat->PutDouble(sqrt(fSE2), 1, 2);
2006             // sen...se1 (Standardfehler der Koeffizienten mn...m1)
2007             // seb (Standardfehler der Konstanten b)
2008             if ( RGetVariances( pV, pMatX, M+1, N, nCase != 2, FALSE ) )
2009             {
2010                 for (i = 0; i < M+1; i++)
2011                     pResMat->PutDouble( sqrt(fSE2 * pV->GetDouble(i)), M-i, 1 );
2012             }
2013             else
2014             {
2015                 for (i = 0; i < M+1; i++)
2016                     pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), i, 1);
2017             }
2018         }
2019         // F (F-Statistik)
2020         if (fSQR == 0.0)
2021             pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3);
2022         else
2023             pResMat->PutDouble(((double)(N-M-1))*fSQE/fSQR/((double)M),0, 3);
2024         // df (Freiheitsgrad)
2025         pResMat->PutDouble(((double)(N-M-1)), 1, 3);
2026     }
2027     else
2028     {
2029         if (N-M == 0)
2030         {
2031             pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2);
2032             for (i = 0; i < M+1; i++)
2033                 pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), i, 1);
2034         }
2035         else
2036         {
2037             double fSE2 = fSQR/(N-M);
2038             pResMat->PutDouble(sqrt(fSE2), 1, 2);
2039             if ( RGetVariances( pV, pMatX, M, N, nCase != 2, TRUE ) )
2040             {
2041                 for (i = 0; i < M; i++)
2042                     pResMat->PutDouble( sqrt(fSE2 * pV->GetDouble(i)), M-i-1, 1 );
2043                 pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), M, 1);
2044             }
2045             else
2046             {
2047                 for (i = 0; i < M+1; i++)
2048                     pResMat->PutString(ScGlobal::GetRscString(STR_NV_STR), i, 1);
2049             }
2050         }
2051         if (fSQR == 0.0)
2052             pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3);
2053         else
2054             pResMat->PutDouble(((double)(N-M))*fSQE/fSQR/((double)M),0, 3);
2055         pResMat->PutDouble(((double)(N-M)), 1, 3);
2056     }
2057 }
2058
2059 void ScInterpreter::ScRGP()
2060 {
2061     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScRGP" );
2062     CalulateRGPRKP(FALSE);
2063 }
2064 bool ScInterpreter::CheckMatrix(BOOL _bLOG,BOOL _bTrendGrowth,BYTE& nCase,SCSIZE& nCX,SCSIZE& nCY,SCSIZE& nRX,SCSIZE& nRY,SCSIZE& M,SCSIZE& N,ScMatrixRef& pMatX,ScMatrixRef& pMatY)
2065 {
2066     nCX = 0;
2067     nCY = 0;
2068     nRX = 0;
2069     nRY = 0;
2070     M = 0;
2071     N = 0;
2072     pMatY->GetDimensions(nCY, nRY);
2073     const SCSIZE nCountY = nCY * nRY;
2074     for ( SCSIZE i = 0; i < nCountY; i++ )
2075     {
2076         if (!pMatY->IsValue(i))
2077         {
2078             PushIllegalArgument();
2079             return false;
2080         } // if (!pMatY->IsValue(i))
2081     } // for ( SCSIZE i = 0; i < nCountY; i++ )
2082     if ( _bLOG )
2083     {
2084         for (SCSIZE nElem = 0; nElem < nCountY; nElem++)
2085         {
2086             const double fVal = pMatY->GetDouble(nElem);
2087             if (fVal <= 0.0)
2088             {
2089                 PushIllegalArgument();
2090                 return false;
2091             }
2092             else
2093                 pMatY->PutDouble(log(fVal), nElem);
2094         } // for (nElem = 0; nElem < nCountY; nElem++)
2095     } // if ( _bRKP )
2096
2097
2098     if (pMatX)
2099     {
2100         pMatX->GetDimensions(nCX, nRX);
2101         const SCSIZE nCountX = nCX * nRX;
2102         for ( SCSIZE i = 0; i < nCountX; i++ )
2103             if (!pMatX->IsValue(i))
2104             {
2105                 PushIllegalArgument();
2106                 return false;
2107             }
2108         if (nCX == nCY && nRX == nRY)
2109             nCase = 1;                  // einfache Regression
2110         else if (nCY != 1 && nRY != 1)
2111         {
2112             PushIllegalArgument();
2113             return false;
2114         }
2115         else if (nCY == 1)
2116         {
2117             if (nRX != nRY)
2118             {
2119                 PushIllegalArgument();
2120                 return false;
2121             }
2122             else
2123             {
2124                 nCase = 2;              // zeilenweise
2125                 N = nRY;
2126                 M = nCX;
2127             }
2128         }
2129         else if (nCX != nCY)
2130         {
2131             PushIllegalArgument();
2132             return false;
2133         }
2134         else
2135         {
2136             nCase = 3;                  // spaltenweise
2137             N = nCY;
2138             M = nRX;
2139         }
2140     }
2141     else
2142     {
2143         pMatX = GetNewMat(nCY, nRY);
2144         if ( _bTrendGrowth )
2145         {
2146             nCX = nCY;
2147             nRX = nRY;
2148         }
2149         if (!pMatX)
2150         {
2151             PushIllegalArgument();
2152             return false;
2153         }
2154         for ( SCSIZE i = 1; i <= nCountY; i++ )
2155             pMatX->PutDouble((double)i, i-1);
2156         nCase = 1;
2157     }
2158     return true;
2159 }
2160 void ScInterpreter::CalulateRGPRKP(BOOL _bRKP)
2161 {
2162     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::CheckMatrix" );
2163     BYTE nParamCount = GetByte();
2164     if ( !MustHaveParamCount( nParamCount, 1, 4 ) )
2165         return;
2166     BOOL bConstant, bStats;
2167     if (nParamCount == 4)
2168         bStats = GetBool();
2169     else
2170         bStats = FALSE;
2171     if (nParamCount >= 3)
2172         bConstant = GetBool();
2173     else
2174         bConstant = TRUE;
2175     ScMatrixRef pMatX;
2176     ScMatrixRef pMatY;
2177     if (nParamCount >= 2)
2178         pMatX = GetMatrix();
2179     else
2180         pMatX = NULL;
2181     pMatY = GetMatrix();
2182     if (!pMatY)
2183     {
2184         PushIllegalParameter();
2185         return;
2186     } // if (!pMatY)
2187     BYTE nCase;                         // 1 = normal, 2,3 = mehrfach
2188     SCSIZE nCX, nCY;
2189     SCSIZE nRX, nRY;
2190     SCSIZE M = 0, N = 0;
2191     if ( !CheckMatrix(_bRKP,FALSE,nCase,nCX,nCY,nRX,nRY,M,N,pMatX,pMatY) )
2192         return;
2193
2194     ScMatrixRef pResMat;
2195     if (nCase == 1)
2196     {
2197         if (!bStats)
2198             pResMat = GetNewMat(2,1);
2199         else
2200             pResMat = GetNewMat(2,5);
2201         if (!pResMat)
2202         {
2203             PushIllegalArgument();
2204             return;
2205         }
2206         double fCount   = 0.0;
2207         double fSumX    = 0.0;
2208         double fSumSqrX = 0.0;
2209         double fSumY    = 0.0;
2210         double fSumSqrY = 0.0;
2211         double fSumXY   = 0.0;
2212         double fValX, fValY;
2213         for (SCSIZE i = 0; i < nCY; i++)
2214             for (SCSIZE j = 0; j < nRY; j++)
2215             {
2216                 fValX = pMatX->GetDouble(i,j);
2217                 fValY = pMatY->GetDouble(i,j);
2218                 fSumX    += fValX;
2219                 fSumSqrX += fValX * fValX;
2220                 fSumY    += fValY;
2221                 fSumSqrY += fValY * fValY;
2222                 fSumXY   += fValX*fValY;
2223                 fCount++;
2224             }
2225         if (fCount < 1.0)
2226             PushNoValue();
2227         else
2228         {
2229             double f1 = fCount*fSumXY-fSumX*fSumY;
2230             double fX = fCount*fSumSqrX-fSumX*fSumX;
2231             double b, m;
2232             if (bConstant)
2233             {
2234                 b = fSumY/fCount - f1/fX*fSumX/fCount;
2235                 m = f1/fX;
2236             }
2237             else
2238             {
2239                 b = 0.0;
2240                 m = fSumXY/fSumSqrX;
2241             }
2242             pResMat->PutDouble(_bRKP ? exp(m) : m, 0, 0);
2243             pResMat->PutDouble(_bRKP ? exp(b) : b, 1, 0);
2244             if (bStats)
2245             {
2246                 double fY = fCount*fSumSqrY-fSumY*fSumY;
2247                 double fSyx = fSumSqrY-b*fSumY-m*fSumXY;
2248                 double fR2 = f1*f1/(fX*fY);
2249                 pResMat->PutDouble (fR2, 0, 2);
2250                 if (fCount < 3.0)
2251                 {
2252                     pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 1 );
2253                     pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 1 );
2254                     pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 1, 2 );
2255                     pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3 );
2256                 }
2257                 else
2258                 {
2259                     pResMat->PutDouble(sqrt(fSyx*fCount/(fX*(fCount-2.0))), 0, 1);
2260                     pResMat->PutDouble(sqrt(fSyx*fSumSqrX/fX/(fCount-2.0)), 1, 1);
2261                     pResMat->PutDouble(
2262                         sqrt((fCount*fSumSqrY - fSumY*fSumY - f1*f1/fX)/
2263                              (fCount*(fCount-2.0))), 1, 2);
2264                     if (fR2 == 1.0)
2265                         pResMat->PutString(ScGlobal::GetRscString(STR_NO_VALUE), 0, 3 );
2266                     else
2267                         pResMat->PutDouble(fR2*(fCount-2.0)/(1.0-fR2), 0, 3);
2268                 }
2269                 pResMat->PutDouble(((double)(nCY*nRY))-2.0, 1, 3);
2270                 pResMat->PutDouble(fY/fCount-fSyx, 0, 4);
2271                 pResMat->PutDouble(fSyx, 1, 4);
2272             }
2273         }
2274     } // if (nCase == 1)
2275     if ( nCase != 1 )
2276     {
2277         SCSIZE i, j, k;
2278         if (!bStats)
2279             pResMat = GetNewMat(M+1,1);
2280         else
2281             pResMat = GetNewMat(M+1,5);
2282         if (!pResMat)
2283         {
2284             PushIllegalArgument();
2285             return;
2286         }
2287         ScMatrixRef pQ = GetNewMat(M+1, M+2);
2288         ScMatrixRef pE = GetNewMat(M+2, 1);
2289         ScMatrixRef pV = GetNewMat(M+1, 1);
2290         pE->PutDouble(0.0, M+1);
2291         pQ->FillDouble(0.0, 0, 0, M, M+1);
2292         if (nCase == 2)
2293         {
2294             for (k = 0; k < N; k++)
2295             {
2296                 double Yk = pMatY->GetDouble(k);
2297                 pE->PutDouble( pE->GetDouble(M+1)+Yk*Yk, M+1 );
2298                 double sumYk = pQ->GetDouble(0, M+1) + Yk;
2299                 pQ->PutDouble( sumYk, 0, M+1 );
2300                 pE->PutDouble( sumYk, 0 );
2301                 for (i = 0; i < M; i++)
2302                 {
2303                     double Xik = pMatX->GetDouble(i,k);
2304                     double sumXik = pQ->GetDouble(0, i+1) + Xik;
2305                     pQ->PutDouble( sumXik, 0, i+1);
2306                     pQ->PutDouble( sumXik, i+1, 0);
2307                     double sumXikYk = pQ->GetDouble(i+1, M+1) + Xik * Yk;
2308                     pQ->PutDouble( sumXikYk, i+1, M+1);
2309                     pE->PutDouble( sumXikYk, i+1);
2310                     for (j = i; j < M; j++)
2311                     {
2312                         const double fVal = pMatX->GetDouble(j,k);
2313                         double sumXikXjk = pQ->GetDouble(j+1, i+1) +
2314                              Xik * fVal;
2315                         pQ->PutDouble( sumXikXjk, j+1, i+1);
2316                         pQ->PutDouble( sumXikXjk, i+1, j+1);
2317                     }
2318                 }
2319             }
2320         }
2321         else
2322         {
2323             for (k = 0; k < N; k++)
2324             {
2325                 double Yk = pMatY->GetDouble(k);
2326                 pE->PutDouble( pE->GetDouble(M+1)+Yk*Yk, M+1 );
2327                 double sumYk = pQ->GetDouble(0, M+1) + Yk;
2328                 pQ->PutDouble( sumYk, 0, M+1 );
2329                 pE->PutDouble( sumYk, 0 );
2330                 for (i = 0; i < M; i++)
2331                 {
2332                     double Xki = pMatX->GetDouble(k,i);
2333                     double sumXki = pQ->GetDouble(0, i+1) + Xki;
2334                     pQ->PutDouble( sumXki, 0, i+1);
2335                     pQ->PutDouble( sumXki, i+1, 0);
2336                     double sumXkiYk = pQ->GetDouble(i+1, M+1) + Xki * Yk;
2337                     pQ->PutDouble( sumXkiYk, i+1, M+1);
2338                     pE->PutDouble( sumXkiYk, i+1);
2339                     for (j = i; j < M; j++)
2340                     {
2341                         const double fVal = pMatX->GetDouble(k,j);
2342                         double sumXkiXkj = pQ->GetDouble(j+1, i+1) +
2343                              Xki * fVal;
2344                         pQ->PutDouble( sumXkiXkj, j+1, i+1);
2345                         pQ->PutDouble( sumXkiXkj, i+1, j+1);
2346                     }
2347                 }
2348             }
2349         }
2350         if ( !Calculate4(_bRKP,pResMat,pQ,bConstant,N,M) )
2351             return;
2352
2353         if (bStats)
2354             Calculate(pResMat,pE,pQ,pV,pMatX,bConstant,N,M,nCase);
2355     }
2356     PushMatrix(pResMat);
2357 }
2358
2359 void ScInterpreter::ScRKP()
2360 {
2361     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScRKP" );
2362     CalulateRGPRKP(TRUE);
2363 }
2364 // -----------------------------------------------------------------------------
2365 bool ScInterpreter::Calculate4(BOOL _bExp,ScMatrixRef& pResMat,ScMatrixRef& pQ,BOOL bConstant,SCSIZE N,SCSIZE M)
2366 {
2367     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::Calculate4" );
2368     pQ->PutDouble((double)N, 0, 0);
2369     if (bConstant)
2370     {
2371         SCSIZE S, L;
2372         for (S = 0; S < M+1; S++)
2373         {
2374             SCSIZE i = S;
2375             while (i < M+1 && pQ->GetDouble(i, S) == 0.0)
2376                 i++;
2377             if (i >= M+1)
2378             {
2379                 PushNoValue();
2380                 return false;
2381             }
2382             double fVal;
2383             for (L = 0; L < M+2; L++)
2384             {
2385                 fVal = pQ->GetDouble(S, L);
2386                 pQ->PutDouble(pQ->GetDouble(i, L), S, L);
2387                 pQ->PutDouble(fVal, i, L);
2388             }
2389             fVal = 1.0/pQ->GetDouble(S, S);
2390             for (L = 0; L < M+2; L++)
2391                 pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L);
2392             for (i = 0; i < M+1; i++)
2393             {
2394                 if (i != S)
2395                 {
2396                     fVal = -pQ->GetDouble(i, S);
2397                     for (L = 0; L < M+2; L++)
2398                         pQ->PutDouble(
2399                             pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L);
2400                 }
2401             }
2402         }
2403     }
2404     else
2405     {
2406         if ( !Calculate3(M,pQ) )
2407             return false;
2408
2409     }
2410     for (SCSIZE i = 0; i < M+1; i++)
2411     {
2412         const double d = pQ->GetDouble(M-i,M+1);
2413         pResMat->PutDouble(_bExp ? exp(d) : d, i, 0);
2414     } // for (SCSIZE i = 0; i < M+1; i++)
2415     return true;
2416 }
2417
2418 ScMatrixRef ScInterpreter::Calculate2(const BOOL bConstant,const SCSIZE M ,const SCSIZE N,ScMatrixRef& pMatX,ScMatrixRef& pMatY,BYTE nCase)
2419 {
2420     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::Calculate2" );
2421     SCSIZE i, j, k;
2422     ScMatrixRef pQ = GetNewMat(M+1, M+2);
2423     ScMatrixRef pE = GetNewMat(M+2, 1);
2424     pE->PutDouble(0.0, M+1);
2425     pQ->FillDouble(0.0, 0, 0, M, M+1);
2426     if (nCase == 2)
2427     {
2428         for (k = 0; k < N; k++)
2429         {
2430             pE->PutDouble(
2431                 pE->GetDouble(M+1)+pMatY->GetDouble(k)*pMatY->GetDouble(k), M+1);
2432             pQ->PutDouble(pQ->GetDouble(0, M+1) + pMatY->GetDouble(k), 0,   M+1);
2433             pE->PutDouble(pQ->GetDouble(0, M+1), 0);
2434             for (i = 0; i < M; i++)
2435             {
2436                 pQ->PutDouble(pQ->GetDouble(0, i+1)+pMatX->GetDouble(i,k), 0, i+1);
2437                 pQ->PutDouble(pQ->GetDouble(0, i+1), i+1, 0);
2438                 pQ->PutDouble(pQ->GetDouble(i+1, M+1) +
2439                          pMatX->GetDouble(i,k)*pMatY->GetDouble(k), i+1, M+1);
2440                 pE->PutDouble(pQ->GetDouble(i+1, M+1), i+1);
2441                 for (j = i; j < M; j++)
2442                 {
2443                     pQ->PutDouble(pQ->GetDouble(j+1, i+1) +
2444                          pMatX->GetDouble(i,k)*pMatX->GetDouble(j,k), j+1, i+1);
2445                     pQ->PutDouble(pQ->GetDouble(j+1, i+1), i+1, j+1);
2446                 }
2447             }
2448         }
2449     }
2450     else
2451     {
2452         for (k = 0; k < N; k++)
2453         {
2454             pE->PutDouble(
2455                 pE->GetDouble(M+1)+pMatY->GetDouble(k)*pMatY->GetDouble(k), M+1);
2456             pQ->PutDouble(pQ->GetDouble(0, M+1) + pMatY->GetDouble(k), 0,   M+1);
2457             pE->PutDouble(pQ->GetDouble(0, M+1), 0);
2458             for (i = 0; i < M; i++)
2459             {
2460                 pQ->PutDouble(pQ->GetDouble(0, i+1)+pMatX->GetDouble(k,i), 0, i+1);
2461                 pQ->PutDouble(pQ->GetDouble(0, i+1), i+1, 0);
2462                 pQ->PutDouble(pQ->GetDouble(i+1, M+1) +
2463                          pMatX->GetDouble(k,i)*pMatY->GetDouble(k), i+1, M+1);
2464                 pE->PutDouble(pQ->GetDouble(i+1, M+1), i+1);
2465                 for (j = i; j < M; j++)
2466                 {
2467                     pQ->PutDouble(pQ->GetDouble(j+1, i+1) +
2468                          pMatX->GetDouble(k, i)*pMatX->GetDouble(k, j), j+1, i+1);
2469                     pQ->PutDouble(pQ->GetDouble(j+1, i+1), i+1, j+1);
2470                 }
2471             }
2472         }
2473     }
2474     pQ->PutDouble((double)N, 0, 0);
2475     if (bConstant)
2476     {
2477         SCSIZE S, L;
2478         for (S = 0; S < M+1; S++)
2479         {
2480             i = S;
2481             while (i < M+1 && pQ->GetDouble(i, S) == 0.0)
2482                 i++;
2483             if (i >= M+1)
2484             {
2485                 PushNoValue();
2486                 return ScMatrixRef();
2487             }
2488             double fVal;
2489             for (L = 0; L < M+2; L++)
2490             {
2491                 fVal = pQ->GetDouble(S, L);
2492                 pQ->PutDouble(pQ->GetDouble(i, L), S, L);
2493                 pQ->PutDouble(fVal, i, L);
2494             }
2495             fVal = 1.0/pQ->GetDouble(S, S);
2496             for (L = 0; L < M+2; L++)
2497                 pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L);
2498             for (i = 0; i < M+1; i++)
2499             {
2500                 if (i != S)
2501                 {
2502                     fVal = -pQ->GetDouble(i, S);
2503                     for (L = 0; L < M+2; L++)
2504                         pQ->PutDouble(
2505                             pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L);
2506                 }
2507             }
2508         }
2509     }
2510     else
2511     {
2512         if ( !Calculate3(M,pQ) )
2513             return ScMatrixRef();
2514     }
2515     return pQ;
2516 }
2517 bool ScInterpreter::Calculate3(const SCSIZE M ,ScMatrixRef& pQ)
2518 {
2519     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::Calculate3" );
2520     SCSIZE S, L;
2521     for (S = 1; S < M+1; S++)
2522     {
2523         SCSIZE i = S;
2524         while (i < M+1 && pQ->GetDouble(i, S) == 0.0)
2525             i++;
2526         if (i >= M+1)
2527         {
2528             PushNoValue();
2529             return ScMatrixRef();
2530         }
2531         double fVal;
2532         for (L = 1; L < M+2; L++)
2533         {
2534             fVal = pQ->GetDouble(S, L);
2535             pQ->PutDouble(pQ->GetDouble(i, L), S, L);
2536             pQ->PutDouble(fVal, i, L);
2537         }
2538         fVal = 1.0/pQ->GetDouble(S, S);
2539         for (L = 1; L < M+2; L++)
2540             pQ->PutDouble(pQ->GetDouble(S, L)*fVal, S, L);
2541         for (i = 1; i < M+1; i++)
2542         {
2543             if (i != S)
2544             {
2545                 fVal = -pQ->GetDouble(i, S);
2546                 for (L = 1; L < M+2; L++)
2547                     pQ->PutDouble(
2548                         pQ->GetDouble(i,L)+fVal*pQ->GetDouble(S,L),i,L);
2549             }
2550         }
2551         pQ->PutDouble(0.0, 0, M+1);
2552     } // for (S = 1; S < M+1; S++)
2553     return true;
2554 }
2555
2556 void ScInterpreter::ScTrend()
2557 {
2558     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScTrend" );
2559     CalculateTrendGrowth(FALSE);
2560 }
2561 void ScInterpreter::CalculateTrendGrowth(BOOL _bGrowth)
2562 {
2563     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::CalculateTrendGrowth" );
2564     BYTE nParamCount = GetByte();
2565     if ( !MustHaveParamCount( nParamCount, 1, 4 ) )
2566         return;
2567     BOOL bConstant;
2568     if (nParamCount == 4)
2569         bConstant = GetBool();
2570     else
2571         bConstant = TRUE;
2572     ScMatrixRef pMatX;
2573     ScMatrixRef pMatY;
2574     ScMatrixRef pMatNewX;
2575     if (nParamCount >= 3)
2576         pMatNewX = GetMatrix();
2577     else
2578         pMatNewX = NULL;
2579     if (nParamCount >= 2)
2580         pMatX = GetMatrix();
2581     else
2582         pMatX = NULL;
2583     pMatY = GetMatrix();
2584     if (!pMatY)
2585     {
2586         PushIllegalParameter();
2587         return;
2588     } // if (!pMatY)
2589
2590     BYTE nCase;                         // 1 = normal, 2,3 = mehrfach
2591     SCSIZE nCX, nCY;
2592     SCSIZE nRX, nRY;
2593     SCSIZE M = 0, N = 0;
2594     if ( !CheckMatrix(_bGrowth,TRUE,nCase,nCX,nCY,nRX,nRY,M,N,pMatX,pMatY) )
2595         return;
2596
2597
2598     SCSIZE nCXN, nRXN;
2599     SCSIZE nCountXN;
2600     if (!pMatNewX)
2601     {
2602         nCXN = nCX;
2603         nRXN = nRX;
2604         nCountXN = nCXN * nRXN;
2605         pMatNewX = pMatX;
2606     }
2607     else
2608     {
2609         pMatNewX->GetDimensions(nCXN, nRXN);
2610         if ((nCase == 2 && nCX != nCXN) || (nCase == 3 && nRX != nRXN))
2611         {
2612             PushIllegalArgument();
2613             return;
2614         }
2615         nCountXN = nCXN * nRXN;
2616         for ( SCSIZE i = 0; i < nCountXN; i++ )
2617             if (!pMatNewX->IsValue(i))
2618             {
2619                 PushIllegalArgument();
2620                 return;
2621             }
2622     }
2623     ScMatrixRef pResMat;
2624     if (nCase == 1)
2625     {
2626         double fCount   = 0.0;
2627         double fSumX    = 0.0;
2628         double fSumSqrX = 0.0;
2629         double fSumY    = 0.0;
2630         double fSumSqrY = 0.0;
2631         double fSumXY   = 0.0;
2632         double fValX, fValY;
2633         SCSIZE i;
2634         for (i = 0; i < nCY; i++)
2635             for (SCSIZE j = 0; j < nRY; j++)
2636             {
2637                 fValX = pMatX->GetDouble(i,j);
2638                 fValY = pMatY->GetDouble(i,j);
2639                 fSumX    += fValX;
2640                 fSumSqrX += fValX * fValX;
2641                 fSumY    += fValY;
2642                 fSumSqrY += fValY * fValY;
2643                 fSumXY   += fValX*fValY;
2644                 fCount++;
2645             }
2646         if (fCount < 1.0)
2647         {
2648             PushNoValue();
2649             return;
2650         }
2651         else
2652         {
2653             double f1 = fCount*fSumXY-fSumX*fSumY;
2654             double fX = fCount*fSumSqrX-fSumX*fSumX;
2655             double b, m;
2656             if (bConstant)
2657             {
2658                 b = fSumY/fCount - f1/fX*fSumX/fCount;
2659                 m = f1/fX;
2660             }
2661             else
2662             {
2663                 b = 0.0;
2664                 m = fSumXY/fSumSqrX;
2665             }
2666             pResMat = GetNewMat(nCXN, nRXN);
2667             if (!pResMat)
2668             {
2669                 PushIllegalArgument();
2670                 return;
2671             }
2672             for (i = 0; i < nCountXN; i++)
2673             {
2674                 const double d = pMatNewX->GetDouble(i)*m+b;
2675                 pResMat->PutDouble(_bGrowth ? exp(d) : d, i);
2676             }
2677         }
2678     }
2679     else
2680     {
2681         ScMatrixRef pQ = Calculate2(bConstant,M ,N,pMatX,pMatY,nCase);
2682         if ( !pQ.Is() )
2683             return;
2684         if (nCase == 2)
2685         {
2686             pResMat = GetNewMat(1, nRXN);
2687             if (!pResMat)
2688             {
2689                 PushIllegalArgument();
2690                 return;
2691             }
2692             double fVal;
2693             for (SCSIZE i = 0; i < nRXN; i++)
2694             {
2695                 fVal = pQ->GetDouble(0, M+1);
2696                 for (SCSIZE j = 0; j < M; j++)
2697                     fVal += pQ->GetDouble(j+1, M+1)*pMatNewX->GetDouble(j, i);
2698                 pResMat->PutDouble(_bGrowth ? exp(fVal) : fVal, i);
2699             }
2700         }
2701         else
2702         {
2703             pResMat = GetNewMat(nCXN, 1);
2704             if (!pResMat)
2705             {
2706                 PushIllegalArgument();
2707                 return;
2708             }
2709             double fVal;
2710             for (SCSIZE i = 0; i < nCXN; i++)
2711             {
2712                 fVal = pQ->GetDouble(0, M+1);
2713                 for (SCSIZE j = 0; j < M; j++)
2714                     fVal += pQ->GetDouble(j+1, M+1)*pMatNewX->GetDouble(i, j);
2715                 pResMat->PutDouble(_bGrowth ? exp(fVal) : fVal, i);
2716             }
2717         }
2718     }
2719     PushMatrix(pResMat);
2720 }
2721
2722 void ScInterpreter::ScGrowth()
2723 {
2724     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScGrowth" );
2725     CalculateTrendGrowth(TRUE);
2726 }
2727
2728 void ScInterpreter::ScMatRef()
2729 {
2730     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScMatRef" );
2731     // Falls Deltarefs drin sind...
2732     Push( (FormulaToken&)*pCur );
2733     ScAddress aAdr;
2734     PopSingleRef( aAdr );
2735     ScFormulaCell* pCell = (ScFormulaCell*) GetCell( aAdr );
2736     if( pCell && pCell->GetCellType() == CELLTYPE_FORMULA )
2737     {
2738         const ScMatrix* pMat = pCell->GetMatrix();
2739         if( pMat )
2740         {
2741             SCSIZE nCols, nRows;
2742             pMat->GetDimensions( nCols, nRows );
2743             SCSIZE nC = static_cast<SCSIZE>(aPos.Col() - aAdr.Col());
2744             SCSIZE nR = static_cast<SCSIZE>(aPos.Row() - aAdr.Row());
2745             if ((nCols <= nC && nCols != 1) || (nRows <= nR && nRows != 1))
2746                 PushNA();
2747             else
2748             {
2749                 ScMatValType nMatValType;
2750                 const ScMatrixValue* pMatVal = pMat->Get( nC, nR, nMatValType);
2751                 if (ScMatrix::IsNonValueType( nMatValType))
2752                 {
2753                     if (ScMatrix::IsEmptyPathType( nMatValType))
2754                     {   // result of empty FALSE jump path
2755                         nFuncFmtType = NUMBERFORMAT_LOGICAL;
2756                         PushInt(0);
2757                     }
2758                     else if (ScMatrix::IsEmptyType( nMatValType))
2759                     {
2760                         // Not inherited (really?) and display as empty string, not 0.
2761                         PushTempToken( new ScEmptyCellToken( false, true));
2762                     }
2763                     else
2764                         PushString( pMatVal->GetString() );
2765                 }
2766                 else
2767                 {
2768                     PushDouble(pMatVal->fVal);  // handles DoubleError
2769                     pDok->GetNumberFormatInfo( nCurFmtType, nCurFmtIndex, aAdr, pCell );
2770                     nFuncFmtType = nCurFmtType;
2771                     nFuncFmtIndex = nCurFmtIndex;
2772                 }
2773             }
2774         }
2775         else
2776         {
2777             // If not a result matrix, obtain the cell value.
2778             USHORT nErr = pCell->GetErrCode();
2779             if (nErr)
2780                 PushError( nErr );
2781             else if( pCell->IsValue() )
2782                 PushDouble( pCell->GetValue() );
2783             else
2784             {
2785                 String aVal;
2786                 pCell->GetString( aVal );
2787                 PushString( aVal );
2788             }
2789             pDok->GetNumberFormatInfo( nCurFmtType, nCurFmtIndex, aAdr, pCell );
2790             nFuncFmtType = nCurFmtType;
2791             nFuncFmtIndex = nCurFmtIndex;
2792         }
2793     }
2794     else
2795         PushError( errNoRef );
2796 }
2797
2798 void ScInterpreter::ScInfo()
2799 {
2800     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "sc", "er", "ScInterpreter::ScInfo" );
2801     if( MustHaveParamCount( GetByte(), 1 ) )
2802     {
2803         String aStr = GetString();
2804         ScCellKeywordTranslator::transKeyword(aStr, ScGlobal::GetLocale(), ocInfo);
2805         if( aStr.EqualsAscii( "SYSTEM" ) )
2806             PushString( String( RTL_CONSTASCII_USTRINGPARAM( SC_INFO_OSVERSION ) ) );
2807         else if( aStr.EqualsAscii( "OSVERSION" ) )
2808             PushString( String( RTL_CONSTASCII_USTRINGPARAM( "Windows (32-bit) NT 5.01" ) ) );
2809         else if( aStr.EqualsAscii( "RELEASE" ) )
2810             PushString( ::utl::Bootstrap::getBuildIdData( ::rtl::OUString() ) );
2811         else if( aStr.EqualsAscii( "NUMFILE" ) )
2812             PushDouble( 1 );
2813         else if( aStr.EqualsAscii( "RECALC" ) )
2814             PushString( ScGlobal::GetRscString( pDok->GetAutoCalc() ? STR_RECALC_AUTO : STR_RECALC_MANUAL ) );
2815         else
2816             PushIllegalArgument();
2817     }
2818 }