sc/source/ui/optdlg/calcoptionsdlg.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <sal/config.h>
  11
  12 #include <algorithm>
  13 #include <cmath>
  14
  15 #include "calcconfig.hxx"
  16 #include "calcoptionsdlg.hxx"
  17 #include "docfunc.hxx"
  18 #include "docsh.hxx"
  19 #include "interpre.hxx"
  20 #include "sc.hrc"
  21 #include "scresid.hxx"
  22 #include "scopetools.hxx"
  23 #include "viewdata.hxx"
  24
  25 #include <com/sun/star/frame/Desktop.hpp>
  26 #include <com/sun/star/frame/XDesktop2.hpp>
  27
  28 #include <comphelper/random.hxx>
  29 #include <svtools/svlbitm.hxx>
  30 #include <svtools/treelistentry.hxx>
  31
  32 #if HAVE_FEATURE_OPENCL
  33 #include "formulagroup.hxx"
  34 #include "globalnames.hxx"
  35 #endif
  36
  37 namespace {
  38
  39 formula::FormulaGrammar::AddressConvention toAddressConvention(sal_Int32 nPos)
  40 {
  41     switch (nPos)
  42     {
  43         case 1:
  44             return formula::FormulaGrammar::CONV_OOO;
  45         case 2:
  46             return formula::FormulaGrammar::CONV_XL_A1;
  47         case 3:
  48             return formula::FormulaGrammar::CONV_XL_R1C1;
  49         case 4:
  50             return formula::FormulaGrammar::CONV_A1_XL_A1;
  51         case 0:
  52         default:
  53             ;
  54     }
  55
  56     return formula::FormulaGrammar::CONV_UNSPECIFIED;
  57 }
  58
  59 sal_Int32 toSelectedItem( formula::FormulaGrammar::AddressConvention eConv )
  60 {
  61     switch (eConv)
  62     {
  63         case formula::FormulaGrammar::CONV_OOO:
  64             return 1;
  65         case formula::FormulaGrammar::CONV_XL_A1:
  66             return 2;
  67         case formula::FormulaGrammar::CONV_XL_R1C1:
  68             return 3;
  69         case formula::FormulaGrammar::CONV_A1_XL_A1:
  70             return 4;
  71         default:
  72             ;
  73     }
  74     return 0;
  75 }
  76
  77 }
  78
  79 ScCalcOptionsDialog::ScCalcOptionsDialog(vcl::Window* pParent, const ScCalcConfig& rConfig)
  80     : ModalDialog(pParent, "FormulaCalculationOptions",
  81         "modules/scalc/ui/formulacalculationoptions.ui")
  82     , maConfig(rConfig)
  83     , mbSelectedEmptyStringAsZero(rConfig.mbEmptyStringAsZero)
  84 {
  85     get(mpTestButton, "test");
  86     get(mpOpenclInfoList, "opencl_list");
  87     get(mpBtnAutomaticSelectionTrue, "automatic_select_true");
  88     get(mpBtnAutomaticSelectionFalse, "automatic_select_false");
  89     get(mpFtFrequency, "frequency");
  90     get(mpFtComputeUnits, "compute_units");
  91     get(mpFtMemory, "memory");
  92
  93     get(mpConversion,"comboConversion");
  94     mpConversion->SelectEntryPos(static_cast<sal_Int32>(rConfig.meStringConversion), true);
  95     mpConversion->SetSelectHdl(LINK(this, ScCalcOptionsDialog, ConversionModifiedHdl));
  96
  97     get(mpEmptyAsZero,"checkEmptyAsZero");
  98     mpEmptyAsZero->Check(rConfig.mbEmptyStringAsZero);
  99     mpEmptyAsZero->SetClickHdl(LINK(this, ScCalcOptionsDialog, AsZeroModifiedHdl));
 100     CoupleEmptyAsZeroToStringConversion();
 101
 102     get(mpSyntax,"comboSyntaxRef");
 103     mpSyntax->SelectEntryPos( toSelectedItem(rConfig.meStringRefAddressSyntax) );
 104     mpSyntax->SetSelectHdl(LINK(this, ScCalcOptionsDialog, SyntaxModifiedHdl));
 105
 106     get(mpUseOpenCL,"CBUseOpenCL");
 107     mpUseOpenCL->Check(rConfig.mbOpenCLSubsetOnly);
 108     mpUseOpenCL->SetClickHdl(LINK(this, ScCalcOptionsDialog, CBUseOpenCLHdl));
 109
 110     get(mpSpinButton,"spinOpenCLSize");
 111     mpSpinButton->SetValue(rConfig.mnOpenCLMinimumFormulaGroupSize);
 112     mpSpinButton->SetModifyHdl(LINK(this, ScCalcOptionsDialog, SpinOpenCLMinSizeHdl));
 113
 114     get(mpEditField, "entry");
 115     mpEditField->SetText(ScOpCodeSetToSymbolicString(maConfig.maOpenCLSubsetOpCodes));
 116     mpEditField->set_height_request(4 * mpEditField->GetTextHeight());
 117
 118     mpEditField->SetModifyHdl(LINK(this, ScCalcOptionsDialog, EditModifiedHdl));
 119
 120     mpOpenclInfoList->set_height_request(4* mpOpenclInfoList->GetTextHeight());
 121     mpOpenclInfoList->SetStyle(mpOpenclInfoList->GetStyle() | WB_CLIPCHILDREN | WB_FORCE_MAKEVISIBLE);
 122     mpOpenclInfoList->SetHighlightRange();
 123     mpOpenclInfoList->GetParent()->Hide();
 124     mpOpenclInfoList->SetSelectHdl(LINK(this, ScCalcOptionsDialog, DeviceSelHdl));
 125
 126     mpBtnAutomaticSelectionTrue->SetToggleHdl(LINK(this, ScCalcOptionsDialog, BtnAutomaticSelectHdl));
 127
 128     maSoftware = get<vcl::Window>("software")->GetText();
 129
 130     mpTestButton->SetClickHdl(LINK(this, ScCalcOptionsDialog, TestClickHdl));
 131 }
 132
 133 ScCalcOptionsDialog::~ScCalcOptionsDialog()
 134 {
 135     disposeOnce();
 136 }
 137
 138 void ScCalcOptionsDialog::dispose()
 139 {
 140     mpUseOpenCL.clear();
 141     mpSpinButton.clear();
 142     mpEditField.clear();
 143     mpTestButton.clear();
 144     mpFtFrequency.clear();
 145     mpFtComputeUnits.clear();
 146     mpFtMemory.clear();
 147     mpOpenclInfoList.clear();
 148     mpBtnAutomaticSelectionTrue.clear();
 149     mpBtnAutomaticSelectionFalse.clear();
 150     ModalDialog::dispose();
 151 }
 152
 153 void ScCalcOptionsDialog::OpenCLAutomaticSelectionChanged()
 154 {
 155     bool bValue = mpBtnAutomaticSelectionTrue->IsChecked();
 156     if(bValue)
 157         mpOpenclInfoList->Disable();
 158     else
 159         mpOpenclInfoList->Enable();
 160
 161     maConfig.mbOpenCLAutoSelect = bValue;
 162 }
 163
 164 void ScCalcOptionsDialog::SelectedDeviceChanged()
 165 {
 166 #if HAVE_FEATURE_OPENCL
 167     SvTreeListEntry* pEntry = mpOpenclInfoList->GetModel()->GetView(0)->FirstSelected();
 168     if(!pEntry)
 169         return;
 170
 171     OpenCLDeviceInfo* pInfo = static_cast<OpenCLDeviceInfo*>(pEntry->GetUserData());
 172     if(pInfo)
 173     {
 174         mpFtFrequency->SetText(OUString::number(pInfo->mnFrequency));
 175         mpFtComputeUnits->SetText(OUString::number(pInfo->mnComputeUnits));
 176         mpFtMemory->SetText(OUString::number(pInfo->mnMemory/1024/1024));
 177     }
 178     else
 179     {
 180         mpFtFrequency->SetText(OUString());
 181         mpFtComputeUnits->SetText(OUString());
 182         mpFtMemory->SetText(OUString());
 183     }
 184
 185     SvLBoxString* pBoxEntry = dynamic_cast<SvLBoxString*>(pEntry->GetItem(1));
 186     if (!pBoxEntry)
 187         return;
 188
 189     OUString aDevice = pBoxEntry->GetText();
 190     // use english string for configuration
 191     if(aDevice == maSoftware)
 192         aDevice = OPENCL_SOFTWARE_DEVICE_CONFIG_NAME;
 193
 194     maConfig.maOpenCLDevice = aDevice;
 195 #endif
 196 }
 197
 198 void ScCalcOptionsDialog::CoupleEmptyAsZeroToStringConversion()
 199 {
 200     switch (maConfig.meStringConversion)
 201     {
 202         case ScCalcConfig::StringConversion::ILLEGAL:
 203             maConfig.mbEmptyStringAsZero = false;
 204             mpEmptyAsZero->Check(false);
 205             mpEmptyAsZero->Enable(false);
 206             break;
 207         case ScCalcConfig::StringConversion::ZERO:
 208             maConfig.mbEmptyStringAsZero = true;
 209             mpEmptyAsZero->Check();
 210             mpEmptyAsZero->Enable(false);
 211             break;
 212         case ScCalcConfig::StringConversion::UNAMBIGUOUS:
 213         case ScCalcConfig::StringConversion::LOCALE:
 214             // Reset to the value the user selected before.
 215             maConfig.mbEmptyStringAsZero = mbSelectedEmptyStringAsZero;
 216             mpEmptyAsZero->Enable(true);
 217             mpEmptyAsZero->Check( mbSelectedEmptyStringAsZero);
 218             break;
 219     }
 220 }
 221
 222 IMPL_LINK(ScCalcOptionsDialog, AsZeroModifiedHdl, CheckBox*, pCheckBox )
 223 {
 224     maConfig.mbEmptyStringAsZero = mbSelectedEmptyStringAsZero = pCheckBox->IsChecked();
 225     return 0;
 226 }
 227
 228 IMPL_LINK(ScCalcOptionsDialog, ConversionModifiedHdl, ListBox*, pConv )
 229 {
 230
 231     maConfig.meStringConversion = (ScCalcConfig::StringConversion)pConv->GetSelectEntryPos();
 232     CoupleEmptyAsZeroToStringConversion();
 233     return 0;
 234 }
 235
 236 IMPL_LINK(ScCalcOptionsDialog, SyntaxModifiedHdl, ListBox*, pSyntax)
 237 {
 238     maConfig.SetStringRefSyntax(toAddressConvention(pSyntax->GetSelectEntryPos()));
 239     return 0;
 240 }
 241
 242 IMPL_LINK(ScCalcOptionsDialog, CBUseOpenCLHdl, CheckBox*, pCheckBox)
 243 {
 244     maConfig.mbOpenCLSubsetOnly = pCheckBox->IsChecked();
 245     return 0;
 246 }
 247
 248 IMPL_LINK(ScCalcOptionsDialog, SpinOpenCLMinSizeHdl, NumericField*, pSpin)
 249 {
 250     maConfig.mnOpenCLMinimumFormulaGroupSize = pSpin->GetValue();
 251     return 0;
 252 }
 253
 254 IMPL_LINK_NOARG(ScCalcOptionsDialog, BtnAutomaticSelectHdl)
 255 {
 256     OpenCLAutomaticSelectionChanged();
 257     return 0;
 258 }
 259
 260 IMPL_LINK_NOARG(ScCalcOptionsDialog, DeviceSelHdl)
 261 {
 262     SelectedDeviceChanged();
 263     return 0;
 264 }
 265
 266 IMPL_LINK(ScCalcOptionsDialog, EditModifiedHdl, Edit*, pCtrl)
 267 {
 268     maConfig.maOpenCLSubsetOpCodes = ScStringToOpCodeSet(pCtrl->GetText());
 269     return 0;
 270 }
 271
 272 namespace {
 273
 274 struct Area
 275 {
 276     OUString msTitle;
 277     int mnRows;
 278
 279     Area(const OUString& rTitle, int nRows = ScInterpreter::GetGlobalConfig().mnOpenCLMinimumFormulaGroupSize + 2) :
 280         msTitle(rTitle),
 281         mnRows(nRows)
 282     {
 283     }
 284
 285     virtual ~Area()
 286     {
 287     }
 288
 289     virtual void addHeader(ScDocument *pDoc, int nTab) const = 0;
 290
 291     virtual void addRow(ScDocument *pDoc, int nRow, int nTab) const = 0;
 292
 293     virtual OUString getSummaryFormula(ScDocument *pDoc, int nTab) const = 0;
 294 };
 295
 296 struct OpenCLTester
 297 {
 298     int mnTestAreas;
 299     ScDocShell* mpDocShell;
 300     ScDocument *mpDoc;
 301     bool mbOldAutoCalc;
 302     ScCalcConfig maOldCalcConfig;
 303
 304     OpenCLTester() :
 305         mnTestAreas(0)
 306     {
 307         css::uno::Reference< css::uno::XComponentContext > xContext( comphelper::getProcessComponentContext() );
 308         css::uno::Reference< css::frame::XDesktop2 > xComponentLoader = css::frame::Desktop::create(xContext);
 309         css::uno::Reference< css::lang::XComponent >
 310             xComponent( xComponentLoader->loadComponentFromURL( "private:factory/scalc",
 311                                                                 "_blank", 0,
 312                                                                 css::uno::Sequence < css::beans::PropertyValue >() ) );
 313         mpDocShell = dynamic_cast<ScDocShell*>(SfxObjectShell::GetShellFromComponent(xComponent));
 314
 315         assert(mpDocShell);
 316
 317         mpDoc = &mpDocShell->GetDocument();
 318
 319         mbOldAutoCalc = mpDoc->GetAutoCalc();
 320         mpDoc->SetAutoCalc(false);
 321         maOldCalcConfig = ScInterpreter::GetGlobalConfig();
 322         ScCalcConfig aConfig(maOldCalcConfig);
 323         aConfig.mnOpenCLMinimumFormulaGroupSize = 20;
 324         ScInterpreter::SetGlobalConfig(aConfig);
 325
 326         mpDoc->SetString(ScAddress(0,0,0), "Result:");
 327     }
 328
 329     void addTest(const Area &rArea)
 330     {
 331         mnTestAreas++;
 332         (void) mpDocShell->GetDocFunc().InsertTable(mnTestAreas, rArea.msTitle, false, true);
 333
 334         rArea.addHeader(mpDoc, mnTestAreas);
 335
 336         for (int i = 0; i < rArea.mnRows; ++i)
 337             rArea.addRow(mpDoc, i, mnTestAreas);
 338
 339         mpDoc->SetString(ScAddress(0,1+mnTestAreas-1,0), rArea.msTitle + ":");
 340         mpDoc->SetString(ScAddress(1,1+mnTestAreas-1,0), rArea.getSummaryFormula(mpDoc, mnTestAreas));
 341
 342         mpDoc->SetString(ScAddress(1,0,0),
 343                         "=IF(SUM(" +
 344                         ScRange(ScAddress(1,1,0),
 345                                 ScAddress(1,1+mnTestAreas-1,0)).Format(SCA_VALID|SCA_VALID_COL|SCA_VALID_ROW) +
 346                         ")=0,\"PASS\",\"FAIL\")");
 347     }
 348 };
 349
 350 struct Op : Area
 351 {
 352     OUString msOp;
 353     double mnRangeLo;
 354     double mnRangeHi;
 355     double mnEpsilon;
 356
 357     Op(const OUString& rTitle,
 358        const OUString& rOp,
 359        double nRangeLo, double nRangeHi,
 360        double nEpsilon) :
 361         Area(rTitle),
 362         msOp(rOp),
 363         mnRangeLo(nRangeLo),
 364         mnRangeHi(nRangeHi),
 365         mnEpsilon(nEpsilon)
 366     {
 367     }
 368
 369     virtual ~Op()
 370     {
 371     }
 372 };
 373
 374 struct UnOp : Op
 375 {
 376     double (*mpFun)(double nArg);
 377     bool (*mpFilterOut)(double nArg);
 378
 379     UnOp(const OUString& rTitle,
 380          const OUString& rOp,
 381          double nRangeLo, double nRangeHi,
 382          double nEpsilon,
 383          double (*pFun)(double nArg),
 384          bool (*pFilterOut)(double nArg) = nullptr) :
 385         Op(rTitle, rOp, nRangeLo, nRangeHi, nEpsilon),
 386         mpFun(pFun),
 387         mpFilterOut(pFilterOut)
 388     {
 389     }
 390
 391     virtual ~UnOp()
 392     {
 393     }
 394
 395     virtual void addHeader(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 396     {
 397         pDoc->SetString(ScAddress(0,0,nTab), "arg");
 398         pDoc->SetString(ScAddress(1,0,nTab), msOp + "(arg)");
 399         pDoc->SetString(ScAddress(2,0,nTab), "expected");
 400     }
 401
 402     virtual void addRow(ScDocument *pDoc, int nRow, int nTab) const SAL_OVERRIDE
 403     {
 404         double nArg;
 405
 406         do {
 407             nArg = comphelper::rng::uniform_real_distribution(mnRangeLo, mnRangeHi);
 408         } while (mpFilterOut != nullptr && mpFilterOut(nArg));
 409
 410         pDoc->SetValue(ScAddress(0,1+nRow,nTab), nArg);
 411
 412         pDoc->SetString(ScAddress(1,1+nRow,nTab),
 413                         "=" + msOp + "(" + ScAddress(0,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) + ")");
 414
 415         pDoc->SetValue(ScAddress(2,1+nRow,nTab), mpFun(nArg));
 416
 417         if (mnEpsilon < 0)
 418         {
 419             // relative epsilon
 420             pDoc->SetString(ScAddress(3,1+nRow,nTab),
 421                             "=IF(ABS((" + ScAddress(1,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 422                             "-" + ScAddress(2,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 423                             ")/" + ScAddress(2,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 424                             ")<=" + OUString::number(-mnEpsilon) +
 425                             ",0,1)");
 426         }
 427         else
 428         {
 429             // absolute epsilon
 430             pDoc->SetString(ScAddress(3,1+nRow,nTab),
 431                             "=IF(ABS(" + ScAddress(1,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 432                             "-" + ScAddress(2,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 433                             ")<=" + OUString::number(mnEpsilon) +
 434                             ",0,1)");
 435         }
 436     }
 437
 438     virtual OUString getSummaryFormula(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 439     {
 440         return "=SUM(" +
 441             ScRange(ScAddress(3,1,nTab),
 442                     ScAddress(3,1+mnRows-1,nTab)).Format(SCA_VALID|SCA_TAB_3D|SCA_VALID_COL|SCA_VALID_ROW|SCA_VALID_TAB, pDoc) +
 443             ")";
 444     }
 445 };
 446
 447 struct BinOp : Op
 448 {
 449     double (*mpFun)(double nLhs, double nRhs);
 450     bool (*mpFilterOut)(double nLhs, double nRhs);
 451
 452     BinOp(const OUString& rTitle,
 453           const OUString& rOp,
 454           double nRangeLo, double nRangeHi,
 455           double nEpsilon,
 456           double (*pFun)(double nLhs, double nRhs),
 457           bool (*pFilterOut)(double nLhs, double nRhs) = nullptr) :
 458         Op(rTitle, rOp, nRangeLo, nRangeHi, nEpsilon),
 459         mpFun(pFun),
 460         mpFilterOut(pFilterOut)
 461     {
 462     }
 463
 464     virtual ~BinOp()
 465     {
 466     }
 467
 468     virtual void addHeader(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 469     {
 470         pDoc->SetString(ScAddress(0,0,nTab), "lhs");
 471         pDoc->SetString(ScAddress(1,0,nTab), "rhs");
 472         pDoc->SetString(ScAddress(2,0,nTab), "lhs" + msOp + "rhs");
 473         pDoc->SetString(ScAddress(3,0,nTab), "expected");
 474     }
 475
 476     virtual void addRow(ScDocument *pDoc, int nRow, int nTab) const SAL_OVERRIDE
 477     {
 478         double nLhs, nRhs;
 479
 480         do {
 481             nLhs = comphelper::rng::uniform_real_distribution(mnRangeLo, mnRangeHi);
 482             nRhs = comphelper::rng::uniform_real_distribution(mnRangeLo, mnRangeHi);
 483         } while (mpFilterOut != nullptr && mpFilterOut(nLhs, nRhs));
 484
 485         pDoc->SetValue(ScAddress(0,1+nRow,nTab), nLhs);
 486         pDoc->SetValue(ScAddress(1,1+nRow,nTab), nRhs);
 487
 488         pDoc->SetString(ScAddress(2,1+nRow,nTab),
 489                         "=" + ScAddress(0,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 490                         msOp + ScAddress(1,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW));
 491
 492         pDoc->SetValue(ScAddress(3,1+nRow,nTab), mpFun(nLhs, nRhs));
 493
 494         pDoc->SetString(ScAddress(4,1+nRow,nTab),
 495                         "=IF(ABS(" + ScAddress(2,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 496                         "-" + ScAddress(3,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 497                         ")<=" + OUString::number(mnEpsilon) +
 498                         ",0,1)");
 499     }
 500
 501     virtual OUString getSummaryFormula(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 502     {
 503         return "=SUM(" +
 504             ScRange(ScAddress(4,1,nTab),
 505                     ScAddress(4,1+mnRows-1,nTab)).Format(SCA_VALID|SCA_TAB_3D|SCA_VALID_COL|SCA_VALID_ROW|SCA_VALID_TAB, pDoc) +
 506             ")";
 507     }
 508 };
 509
 510 struct Round : Area
 511 {
 512     Round() :
 513         Area("Round")
 514     {
 515     }
 516
 517     virtual ~Round()
 518     {
 519     }
 520
 521     virtual void addHeader(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 522     {
 523         pDoc->SetString(ScAddress(0,0,nTab), "x");
 524         pDoc->SetString(ScAddress(1,0,nTab), "n");
 525         pDoc->SetString(ScAddress(2,0,nTab), "ROUND(x,n)");
 526         pDoc->SetString(ScAddress(3,0,nTab), "expected");
 527     }
 528
 529     virtual void addRow(ScDocument *pDoc, int nRow, int nTab) const SAL_OVERRIDE
 530     {
 531         const double nX(comphelper::rng::uniform_real_distribution(0, 100));
 532         const int nN(comphelper::rng::uniform_int_distribution(1, 10));
 533
 534         pDoc->SetValue(ScAddress(0,1+nRow,nTab), nX);
 535         pDoc->SetValue(ScAddress(1,1+nRow,nTab), nN);
 536
 537         pDoc->SetString(ScAddress(2,1+nRow,nTab),
 538                         "=ROUND(" + ScAddress(0,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 539                         "," + ScAddress(1,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 540                         ")");
 541
 542         pDoc->SetValue(ScAddress(3,1+nRow,nTab), ::rtl::math::round(nX, (short) nN, rtl_math_RoundingMode_Corrected));
 543
 544         pDoc->SetString(ScAddress(4,1+nRow,nTab),
 545                         "=IF(ABS(" + ScAddress(2,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 546                         "-" + ScAddress(3,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 547                         ")<=3e-10"
 548                         ",0,1)");
 549     }
 550
 551     virtual OUString getSummaryFormula(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 552     {
 553         return "=SUM(" +
 554             ScRange(ScAddress(4,1,nTab),
 555                     ScAddress(4,1+mnRows-1,nTab)).Format(SCA_VALID|SCA_TAB_3D|SCA_VALID_COL|SCA_VALID_ROW|SCA_VALID_TAB, pDoc) +
 556             ")";
 557     }
 558
 559 };
 560
 561 struct Normdist : Area
 562 {
 563     Normdist() :
 564         Area("Normdist")
 565     {
 566     }
 567
 568     virtual ~Normdist()
 569     {
 570     }
 571
 572     virtual void addHeader(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 573     {
 574         pDoc->SetString(ScAddress(0,0,nTab), "num");
 575         pDoc->SetString(ScAddress(1,0,nTab), "avg");
 576         pDoc->SetString(ScAddress(2,0,nTab), "stdev");
 577         pDoc->SetString(ScAddress(3,0,nTab), "type");
 578         pDoc->SetString(ScAddress(4,0,nTab), "NORMDIST(num,avg,stdev,type)");
 579         pDoc->SetString(ScAddress(5,0,nTab), "expected");
 580     }
 581
 582     virtual void addRow(ScDocument *pDoc, int nRow, int nTab) const SAL_OVERRIDE
 583     {
 584         const double nNum(comphelper::rng::uniform_real_distribution(0, 100));
 585         const double nAvg(comphelper::rng::uniform_real_distribution(0, 100));
 586         const double nStDev(comphelper::rng::uniform_real_distribution(1, 10));
 587         const int nType(comphelper::rng::uniform_int_distribution(0, 1));
 588
 589         pDoc->SetValue(ScAddress(0,1+nRow,nTab), nNum);
 590         pDoc->SetValue(ScAddress(1,1+nRow,nTab), nAvg);
 591         pDoc->SetValue(ScAddress(2,1+nRow,nTab), nStDev);
 592         pDoc->SetValue(ScAddress(3,1+nRow,nTab), nType);
 593
 594         pDoc->SetString(ScAddress(4,1+nRow,nTab),
 595                         "=NORMDIST(" + ScAddress(0,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 596                         "," + ScAddress(1,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 597                         "," + ScAddress(2,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 598                         "," + ScAddress(3,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 599                         ")");
 600
 601         if (nType == 1)
 602             pDoc->SetValue(ScAddress(5,1+nRow,nTab), ScInterpreter::integralPhi((nNum-nAvg)/nStDev));
 603         else
 604             pDoc->SetValue(ScAddress(5,1+nRow,nTab), ScInterpreter::phi((nNum-nAvg)/nStDev)/nStDev);
 605
 606         pDoc->SetString(ScAddress(6,1+nRow,nTab),
 607                         "=IF(ABS(" + ScAddress(4,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 608                         "-" + ScAddress(5,1+nRow,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 609                         ")<=3e-10"
 610                         ",0,1)");
 611     }
 612
 613     virtual OUString getSummaryFormula(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 614     {
 615         return "=SUM(" +
 616             ScRange(ScAddress(6,1,nTab),
 617                     ScAddress(6,1+mnRows-1,nTab)).Format(SCA_VALID|SCA_TAB_3D|SCA_VALID_COL|SCA_VALID_ROW|SCA_VALID_TAB, pDoc) +
 618             ")";
 619     }
 620
 621 };
 622
 623 struct Reduction : Op
 624 {
 625     double mnAccumInitial;
 626     double (*mpFun)(double nAccum, double nArg, const Reduction& rReduction);
 627     bool (*mpFilterOut)(double nArg);
 628
 629     Reduction(const OUString& rTitle,
 630               const OUString& rOp,
 631               double nAccumInitial,
 632               double nRangeLo, double nRangeHi,
 633               double nEpsilon,
 634               double (*pFun)(double nAccum, double nArg, const Reduction& rReduction),
 635               bool (*pFilterOut)(double nArg) = nullptr) :
 636         Op(rTitle, rOp, nRangeLo, nRangeHi, nEpsilon),
 637         mnAccumInitial(nAccumInitial),
 638         mpFun(pFun),
 639         mpFilterOut(pFilterOut)
 640     {
 641     }
 642
 643     virtual ~Reduction()
 644     {
 645     }
 646
 647     virtual void addHeader(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 648     {
 649         pDoc->SetString(ScAddress(0,0,nTab), "x");
 650         pDoc->SetString(ScAddress(1,0,nTab), msOp);
 651         pDoc->SetString(ScAddress(2,0,nTab), "expected");
 652     }
 653
 654     virtual void addRow(ScDocument *pDoc, int nRow, int nTab) const SAL_OVERRIDE
 655     {
 656         double nArg;
 657
 658         do {
 659             nArg = comphelper::rng::uniform_real_distribution(mnRangeLo, mnRangeHi);
 660         } while (mpFilterOut != nullptr && mpFilterOut(nArg));
 661
 662         pDoc->SetValue(ScAddress(0,1+nRow,nTab), nArg);
 663
 664         if (nRow >= mnRows/2-1)
 665         {
 666             pDoc->SetString(ScAddress(1,1+nRow-mnRows/2+1,nTab),
 667                             "=" + msOp + "(" +
 668                             ScRange(ScAddress(0,1+nRow-mnRows/2+1,nTab),
 669                                     ScAddress(0,1+nRow,nTab)).Format(SCA_VALID|SCA_TAB_3D|SCA_VALID_COL|SCA_VALID_ROW) +
 670                             ")");
 671
 672             double nAccum(mnAccumInitial);
 673             for (int i = 0; i < mnRows/2; i++)
 674                 nAccum = mpFun(nAccum, pDoc->GetValue(ScAddress(0,1+nRow-mnRows/2+i+1,nTab)), *this);
 675
 676             pDoc->SetValue(ScAddress(2,1+nRow-mnRows/2+1,nTab), nAccum);
 677
 678             if (mnEpsilon != 0)
 679                 pDoc->SetString(ScAddress(3,1+nRow-mnRows/2+1,nTab),
 680                                 "=IF(ABS(" + ScAddress(1,1+nRow-mnRows/2+1,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 681                                 "-" + ScAddress(2,1+nRow-mnRows/2+1,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 682                                 ")<=" + OUString::number(mnEpsilon) +
 683                                 ",0,1)");
 684             else
 685                 pDoc->SetString(ScAddress(3,1+nRow-mnRows/2+1,nTab),
 686                                 "=IF(" + ScAddress(1,1+nRow-mnRows/2+1,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 687                                 "=" + ScAddress(2,1+nRow-mnRows/2+1,nTab).Format(SCA_VALID_COL|SCA_VALID_ROW) +
 688                                 ",0,1)");
 689         }
 690     }
 691
 692     virtual OUString getSummaryFormula(ScDocument *pDoc, int nTab) const SAL_OVERRIDE
 693     {
 694         return "=SUM(" +
 695             ScRange(ScAddress(3,1+0,nTab),
 696                     ScAddress(3,1+mnRows-mnRows/2-1,nTab)).Format(SCA_VALID|SCA_TAB_3D|SCA_VALID_COL|SCA_VALID_ROW|SCA_VALID_TAB, pDoc) +
 697             ")";
 698     }
 699 };
 700
 701 }
 702
 703 IMPL_STATIC_LINK(
 704     ScCalcOptionsDialog, TestClickHdl, PushButton*, pButton)
 705 {
 706     pButton->Disable();
 707
 708     // Automatically test the current implementation of OpenCL. If it
 709     // seems good, whitelist it. If it seems bad, blacklist it.
 710
 711     std::unique_ptr<OpenCLTester> xTestDocument(new OpenCLTester());
 712
 713     xTestDocument->addTest(BinOp("Plus", "+", -1000, 1000, 3e-10,
 714                                  [] (double nLhs, double nRhs)
 715                                  {
 716                                      return nLhs + nRhs;
 717                                  }));
 718
 719     xTestDocument->addTest(BinOp("Minus", "-", -1000, 1000, 3e-10,
 720                                  [] (double nLhs, double nRhs)
 721                                  {
 722                                      return nLhs - nRhs;
 723                                  }));
 724
 725     xTestDocument->addTest(BinOp("Times", "*", -1000, 1000, 3e-10,
 726                                  [] (double nLhs, double nRhs)
 727                                  {
 728                                      return nLhs * nRhs;
 729                                  }));
 730
 731     xTestDocument->addTest(BinOp("Divided", "/", -1000, 1000, 3e-10,
 732                                  [] (double nLhs, double nRhs)
 733                                  {
 734                                      return nLhs / nRhs;
 735                                  },
 736                                  [] (double, double nRhs)
 737                                  {
 738                                      return (nRhs == 0);
 739                                  }));
 740
 741     xTestDocument->addTest(UnOp("Sin", "SIN", -10, 10, 3e-10,
 742                                 [] (double nArg)
 743                                 {
 744                                     return sin(nArg);
 745                                 }));
 746
 747     xTestDocument->addTest(UnOp("Cos", "COS", -10, 10, 3e-10,
 748                                 [] (double nArg)
 749                                 {
 750                                     return cos(nArg);
 751                                 }));
 752
 753     xTestDocument->addTest(UnOp("Tan", "TAN", 0, 10, -3e-10,
 754                                 [] (double nArg)
 755                                 {
 756                                     return tan(nArg);
 757                                 },
 758                                 [] (double nArg)
 759                                 {
 760                                     return (std::fmod(nArg, M_PI) == M_PI/2);
 761                                 }));
 762
 763     xTestDocument->addTest(UnOp("Atan", "ATAN", -10, 10, 3e-10,
 764                                 [] (double nArg)
 765                                 {
 766                                     return atan(nArg);
 767                                 }));
 768
 769     xTestDocument->addTest(UnOp("Sqrt", "SQRT", 0, 1000, 3e-10,
 770                                 [] (double nArg)
 771                                 {
 772                                     return sqrt(nArg);
 773                                 }));
 774
 775     xTestDocument->addTest(UnOp("Exp", "EXP", 0, 10, 3e-10,
 776                                 [] (double nArg)
 777                                 {
 778                                     return exp(nArg);
 779                                 }));
 780
 781     xTestDocument->addTest(UnOp("Ln", "LN", 0, 1000, 3e-10,
 782                                 [] (double nArg)
 783                                 {
 784                                     return log(nArg);
 785                                 },
 786                                 [] (double nArg)
 787                                 {
 788                                     return (nArg == 0);
 789                                 }));
 790
 791     xTestDocument->addTest(UnOp("NormSInv", "NORMSINV", 0, 1, 3e-10,
 792                                 [] (double nArg)
 793                                 {
 794                                     return ScInterpreter::gaussinv(nArg);
 795                                 }));
 796
 797     xTestDocument->addTest(Round());
 798
 799     xTestDocument->addTest(Normdist());
 800
 801     xTestDocument->addTest(Reduction("Sum", "SUM", 0, -1000, 1000, 3e-10,
 802                                      [] (double nAccum, double nArg, const Reduction&)
 803                                      {
 804                                          return (nAccum + nArg);
 805                                      }));
 806
 807     xTestDocument->addTest(Reduction("Average", "AVERAGE", 0, -1000, 1000, 3e-10,
 808                                      [] (double nAccum, double nArg, const Reduction& rReduction)
 809                                      {
 810                                          return (nAccum + nArg/(rReduction.mnRows/2));
 811                                      }));
 812
 813     xTestDocument->addTest(Reduction("Product", "PRODUCT", 1, 0.1, 2.5, 3e-10,
 814                                      [] (double nAccum, double nArg, const Reduction&)
 815                                      {
 816                                          return (nAccum * nArg);
 817                                      }));
 818
 819     xTestDocument->addTest(Reduction("Min", "MIN", DBL_MAX, -1000, 1000, 0,
 820                                      [] (double nAccum, double nArg, const Reduction&)
 821                                      {
 822                                          return std::min(nAccum, nArg);
 823                                      }));
 824
 825     xTestDocument->addTest(Reduction("Max", "MAX", -DBL_MAX, -1000, 1000, 0,
 826                                      [] (double nAccum, double nArg, const Reduction&)
 827                                      {
 828                                          return std::max(nAccum, nArg);
 829                                      }));
 830
 831     xTestDocument->mpDoc->CalcAll();
 832     ScInterpreter::SetGlobalConfig(xTestDocument->maOldCalcConfig);
 833
 834     return 0;
 835 }
 836
 837 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */