(C++) TestMultiApproximator

TestMultiApproximator is a tool to test the MultiApproximator class.

Downloads

Technical facts

Operating system(s) or programming environment(s)

Lubuntu 15.04 (vivid)

IDE(s):

Qt Creator 3.1.1

Project type:

Console application

C++ standard:

C++98

Compiler(s):

G++ 4.9.2

Libraries used:

STL: GNU ISO C++ Library, version 4.9.2

Qt project file: ./ToolTestMultiApproximator/ToolTestMultiApproximatorConsole.pro


include(../../ConsoleApplication.pri)



include(../../Libraries/GeneralConsole.pri)

include(../../Libraries/Apfloat.pri)

include(../../Libraries/Boost.pri)



include(../../Classes/CppApproximator/CppApproximator.pri)

include(../../Classes/CppCanvas/CppCanvas.pri)

include(../../Classes/CppContainer/CppContainer.pri)

include(../../Classes/CppDotMatrix/CppDotMatrix.pri)

include(../../Classes/CppDrawCanvas/CppDrawCanvas.pri)

include(../../Classes/CppGeometry/CppGeometry.pri)

include(../../Classes/CppMultiApproximator/CppMultiApproximator.pri)

include(../../Classes/CppRibiRegex/CppRibiRegex.pri)

include(../../Classes/CppPlane/CppPlane.pri)

include(../../Classes/CppXml/CppXml.pri)



include(ToolTestMultiApproximatorConsole.pri)



SOURCES += main.cpp

Qt project file: ./ToolTestMultiApproximator/ToolTestMultiApproximatorDesktop.pro


# -Weffc++ does not go with Qwt

include(../../DesktopApplicationNoWeffcpp.pri)



include(../../Libraries/GeneralConsole.pri)

include(../../Libraries/GeneralDesktop.pri)

include(../../Libraries/Apfloat.pri)

include(../../Libraries/Boost.pri)

include(../../Libraries/Qwt.pri)



include(../../Classes/CppApproximator/CppApproximator.pri)

include(../../Classes/CppCanvas/CppCanvas.pri)

include(../../Classes/CppContainer/CppContainer.pri)

include(../../Classes/CppDotMatrix/CppDotMatrix.pri)

include(../../Classes/CppDrawCanvas/CppDrawCanvas.pri)

include(../../Classes/CppGeometry/CppGeometry.pri)

include(../../Classes/CppMultiApproximator/CppMultiApproximator.pri)

include(../../Classes/CppRibiRegex/CppRibiRegex.pri)

include(../../Classes/CppPlane/CppPlane.pri)

include(../../Classes/CppXml/CppXml.pri)



include(ToolTestMultiApproximatorDesktop.pri)



SOURCES += qtmain.cpp

./ToolTestMultiApproximator/ToolTestMultiApproximatorConsole.pri


INCLUDEPATH += \

    ../../Tools/ToolTestMultiApproximator



SOURCES += \

    ../../Tools/ToolTestMultiApproximator/testmultiapproximatormenudialog.cpp



HEADERS += \

    ../../Tools/ToolTestMultiApproximator/testmultiapproximatormenudialog.h



OTHER_FILES += \

    ../../Tools/ToolTestMultiApproximator/Licence.txt

./ToolTestMultiApproximator/ToolTestMultiApproximatorDesktop.pri


include(../../Tools/ToolTestMultiApproximator/ToolTestMultiApproximatorConsole.pri)



RESOURCES += \

    ../../Tools/ToolTestMultiApproximator/ToolTestMultiApproximator.qrc



FORMS += \

    ../../Tools/ToolTestMultiApproximator/qttestmultiapproximatormaindialog.ui \

    ../../Tools/ToolTestMultiApproximator/qttestmultiapproximatormenudialog.ui



SOURCES += \

    ../../Tools/ToolTestMultiApproximator/qttestmultiapproximatormaindialog.cpp \

    ../../Tools/ToolTestMultiApproximator/qttestmultiapproximatormenudialog.cpp



HEADERS += \

    ../../Tools/ToolTestMultiApproximator/qttestmultiapproximatormaindialog.h \

    ../../Tools/ToolTestMultiApproximator/qttestmultiapproximatormenudialog.h

./ToolTestMultiApproximator/ToolTestMultiApproximatorWebsite.pri


include(../../Tools/ToolTestMultiApproximator/ToolTestMultiApproximatorConsole.pri)

SOURCES +=

HEADERS +=

./ToolTestMultiApproximator/main.cpp


#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#pragma GCC diagnostic ignored "-Wunused-but-set-parameter"

#include <iostream>



#include <boost/units/io.hpp>

#include <boost/units/systems/si.hpp>

#include <boost/units/unit.hpp>



#include "multiapproximator.h"

#include "drawcanvas.h"



#pragma GCC diagnostic pop



int main()

{

  //Use Boost.Units to thoroughly check if Approximation is a good template:

  //If it even compiles with Boost.Units, it probably is

  {

    typedef boost::units::quantity<boost::units::si::time> Time;

    typedef boost::units::quantity<boost::units::si::velocity> Velocity;

    ribi::Approximator<Time,Velocity> a;

    a.Add(0.0 * boost::units::si::second,0.0 * boost::units::si::meters_per_second);

    a.Add(2.0 * boost::units::si::second,2.0 * boost::units::si::meters_per_second);

    const Velocity v = a.Approximate(1.0 * boost::units::si::second);

    assert(v >= 0.99 * boost::units::si::meters_per_second

        && v <= 1.01 * boost::units::si::meters_per_second);

    if (v == 0.0 * boost::units::si::meters_per_second)

    {

      std::cout << "Satisfied the compiler";

    }





  }



  typedef ribi::MultiApproximator<double,double> MultiApproximator_t;



  MultiApproximator_t a;

  a.Add(20.0, 3.0);

  a.Add(20.0, 7.0);

  a.Add(30.0,14.0);

  a.Add(30.0,16.0);

  a.Add(40.0, 2.0);

  a.Add(40.0, 8.0);

  a.Add(50.0,12.0);

  a.Add(50.0,18.0);



  const int max_x = 78;

  const int max_y = 20;

  ribi::DrawCanvas c(

    max_x,

    max_y,

    ribi::CanvasColorSystem::invert,

    ribi::CanvasCoordinatSystem::graph

  );



  c.DrawLine(0.0,0.0,max_x,0.0);

  c.DrawLine(0.0,0.0,0.0,max_y);



  //Plot values (note: these won't be visible in Canvas)

  {

    std::vector<double> xs;

    std::vector<double> ys;

    for (const auto p: a.GetContainer())

    {

      c.DrawDot(

        static_cast<double>(p.first),

        static_cast<double>(p.second)

      );

    }

  }



  //Plot approximation

  {

    for (int t=0; t != max_x; ++t)

    {

      try

      {

        const double x = static_cast<double>(t);

        const double y = a.Approximate(x);

        c.DrawDot(x,y);

      }

      catch (ribi::ExceptionNoExtrapolation<MultiApproximator_t::key_type>& e)

      {



      }

    }

  }

  std::cout << c << std::endl;

}



/* Screen output



-

o                                                --

o                                                --

o                            --

o                            oo                  --

o                           -dd-                -o-

o                          -oooo-              -o-

o                         -o-  -o-            -o---

o                        -o-    -o-          -o- --

o                       -o-      -o-        -o-

o                      -o-        -o-      -o-

o                     -o-          -o- -- -o-

o                  ---o-            -o----o-

o                  -oo-              -o--o-

o                  -o-                -oo-

o                  --                  --

o                  --

o                  --                  --

o                                      --

Moooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo-



Press <RETURN> to close this window...



*/

./ToolTestMultiApproximator/qtmain.cpp


//---------------------------------------------------------------------------

/*

ToolTestMultiApproximator, tests the Approximator class

Copyright (C) 2013-2014 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From http://www.richelbilderbeek.nl/ToolTestMultiApproximator.htm

//---------------------------------------------------------------------------

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#pragma GCC diagnostic ignored "-Wunused-but-set-parameter"

#include <QApplication>

#include "qttestmultiapproximatormenudialog.h"

#include "trace.h"

#pragma GCC diagnostic pop



int main(int argc, char *argv[])

{

  QApplication a(argc, argv);

  START_TRACE();

  ribi::QtToolTestMultiApproximatorMenuDialog d;

  d.show();

  return a.exec();

}

./ToolTestMultiApproximator/qttestmultiapproximatormaindialog.h


#ifndef QTTOOLTESTMULTIAPPROXIMATORMAINDIALOG_H

#define QTTOOLTESTMULTIAPPROXIMATORMAINDIALOG_H



#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#include <boost/shared_ptr.hpp>

#include "multiapproximator.h"

#include "qthideandshowdialog.h"

#pragma GCC diagnostic pop



struct QwtPlot;

struct QwtPlotCurve;



namespace Ui {

  class QtToolTestMultiApproximatorMainDialog;

}



namespace ribi {



class QtToolTestMultiApproximatorMainDialog : public QtHideAndShowDialog

{

  Q_OBJECT

  

public:

  explicit QtToolTestMultiApproximatorMainDialog(QWidget *parent = 0) noexcept;

  QtToolTestMultiApproximatorMainDialog(const QtToolTestMultiApproximatorMainDialog&) = delete;

  QtToolTestMultiApproximatorMainDialog& operator=(const QtToolTestMultiApproximatorMainDialog&) = delete;

  ~QtToolTestMultiApproximatorMainDialog() noexcept;

  

private slots:

  void on_button_clicked() noexcept;



private:

  Ui::QtToolTestMultiApproximatorMainDialog *ui;

  typedef double Key;

  typedef double Value;

  typedef std::map<Key,Value> Container;

  typedef std::multimap<Key,Value> MultiContainer;

  typedef MultiApproximator<Key,Value,MultiContainer> MultiApproximator_t;

  typedef Approximator<Key,Value,Container> Approximator_t;

  MultiApproximator_t m_multi_approximator;



  ///The curve of the approximation of the (non-Multi)Approximator

  QwtPlotCurve * const m_curve_approximation;

  //const boost::shared_ptr<QwtPlotCurve> m_curve_approximation; //DONT!



  ///The curve of the approximation of the MultiApproximator

  QwtPlotCurve * const m_curve_multi_approximation;

  //const boost::shared_ptr<QwtPlotCurve> m_curve_multi_approximation; //DONT!



  ///The curve of the raw values of the MultiApproximator

  QwtPlotCurve * const m_curve_multi_values;

  //const boost::shared_ptr<QwtPlotCurve> m_curve_multi_values; //DONT!



  ///The curve of the raw values of the (non-Multi)Approximator

  QwtPlotCurve * const m_curve_values;

  //const boost::shared_ptr<QwtPlotCurve> m_curve_values; //DONT!



  ///Contains the plot of the MultiApproximator

  const boost::shared_ptr<QwtPlot> m_multi_plot;



  ///Contains the plot of the (non-Multi)Approximator

  const boost::shared_ptr<QwtPlot> m_plot;



  void Plot() noexcept;



  #ifndef NDEBUG

  static void Test() noexcept;

  #endif

};



} //~namespace ribi



#endif // QTTOOLTESTMULTIAPPROXIMATORMAINDIALOG_H

./ToolTestMultiApproximator/qttestmultiapproximatormaindialog.cpp


#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#include "qttestmultiapproximatormaindialog.h"



#include <cassert>



#include <qwt_legend.h>

#include <qwt_plot.h>

#include <qwt_plot_curve.h>

#include <qwt_plot_grid.h>

#include <qwt_plot_zoomer.h>



#if QWT_VERSION >= 0x060100

#include <qwt_point_data.h>

#endif



#include "testtimer.h"

#include "ui_qttestmultiapproximatormaindialog.h"

#pragma GCC diagnostic pop



ribi::QtToolTestMultiApproximatorMainDialog::QtToolTestMultiApproximatorMainDialog(QWidget *parent) noexcept :

  QtHideAndShowDialog(parent),

  ui(new Ui::QtToolTestMultiApproximatorMainDialog),

  m_multi_approximator(),

  m_curve_approximation(new QwtPlotCurve),

  m_curve_multi_approximation(new QwtPlotCurve),

  m_curve_multi_values(new QwtPlotCurve),

  m_curve_values(new QwtPlotCurve),

  m_multi_plot(new QwtPlot),

  m_plot(new QwtPlot)

{

  #ifndef NDEBUG

  Test();

  #endif

  ui->setupUi(this);



  //Set up the plots

  assert(m_multi_plot);

  m_multi_plot->setTitle("MultiApproximator");

  m_multi_plot->setAxisTitle(QwtPlot::xBottom,"Key");

  m_multi_plot->setAxisTitle(QwtPlot::yLeft,"Value");

  #ifdef _WIN32

  m_multi_plot->setCanvasBackground(QBrush(QColor(255,255,255)));

  #else

  m_multi_plot->setCanvasBackground(QColor(255,255,255));

  #endif



  assert(m_plot);

  m_plot->setTitle("Approximator");

  m_plot->setAxisTitle(QwtPlot::xBottom,"Key");

  m_plot->setAxisTitle(QwtPlot::yLeft,"Value");

  #ifdef _WIN32

  m_plot->setCanvasBackground(QBrush(QColor(255,255,255)));

  #else

  m_plot->setCanvasBackground(QColor(255,255,255));

  #endif



  //Create plots

  assert(m_curve_multi_values);

  m_curve_multi_values->setTitle("Points");

  m_curve_multi_values->attach(m_multi_plot.get());

  m_curve_multi_values->setStyle(QwtPlotCurve::Dots);

  m_curve_multi_values->setPen(QPen(QColor(255,0,0),5));



  assert(m_curve_multi_approximation);

  m_curve_multi_approximation->setTitle("Approximation");

  m_curve_multi_approximation->attach(m_multi_plot.get());

  m_curve_multi_approximation->setStyle(QwtPlotCurve::Lines);

  m_curve_multi_approximation->setPen(QPen(QColor(0,0,255),3));



  assert(m_curve_values);

  m_curve_values->setTitle("Points");

  m_curve_values->attach(m_plot.get());

  m_curve_values->setStyle(QwtPlotCurve::Dots);

  m_curve_values->setPen(QPen(QColor(255,0,0),5));



  assert(m_curve_approximation);

  m_curve_approximation->setTitle("Approximation");

  m_curve_approximation->attach(m_plot.get());

  m_curve_approximation->setStyle(QwtPlotCurve::Lines);

  m_curve_approximation->setPen(QPen(QColor(0,0,255),3));



  //Add grids

  {

    QwtPlotGrid * const grid = new QwtPlotGrid;

    grid->setPen(QPen(QColor(128,128,128)));

    grid->attach(m_multi_plot.get());

  }

  {

    QwtPlotGrid * const grid = new QwtPlotGrid;

    grid->setPen(QPen(QColor(128,128,128)));

    grid->attach(m_plot.get());

  }

  //Add zoomers

  //{

  //  new QwtPlotZoomer(m_multi_plot->canvas());

  //  new QwtPlotZoomer(m_plot->canvas());

  //}

  //Add legends

  {

    QwtLegend * const legend = new QwtLegend;

    legend->setFrameStyle(QFrame::Box|QFrame::Sunken);

    m_multi_plot->insertLegend(legend, QwtPlot::RightLegend);

  }

  {

    QwtLegend * const legend = new QwtLegend;

    legend->setFrameStyle(QFrame::Box|QFrame::Sunken);

    m_plot->insertLegend(legend, QwtPlot::RightLegend);

  }



  assert(ui->verticalLayout->layout());

  ui->verticalLayout->layout()->addWidget(m_multi_plot.get());

  ui->verticalLayout->layout()->addWidget(m_plot.get());



  m_multi_plot->setAxisScale(

    QwtPlot::xBottom,

    static_cast<double>(ui->box_int_x->minimum()),

    static_cast<double>(ui->box_int_x->maximum())

  );

  m_multi_plot->setAxisScale(

    QwtPlot::yLeft,

    static_cast<double>(ui->box_double_y->minimum()),

    static_cast<double>(ui->box_double_y->maximum())

  );



  m_plot->setAxisScale(

    QwtPlot::xBottom,

    static_cast<double>(ui->box_int_x->minimum()),

    static_cast<double>(ui->box_int_x->maximum())

  );

  m_plot->setAxisScale(

    QwtPlot::yLeft,

    static_cast<double>(ui->box_double_y->minimum()),

    static_cast<double>(ui->box_double_y->maximum())

  );



  //Add some nice testing values

  const double min_x = ui->box_int_x->minimum();

  const double max_x = ui->box_int_x->maximum();

  const double min_y = ui->box_double_y->minimum();

  const double max_y = ui->box_double_y->maximum();

  const double dy = max_y / 4.0;



  ui->box_int_x->setValue(min_x / 2);

  ui->box_double_y->setValue((max_y / 2.0) + dy);

  on_button_clicked();

  ui->box_double_y->setValue((max_y / 2.0) - dy);

  on_button_clicked();



  ui->box_int_x->setValue(min_x / 4);

  ui->box_double_y->setValue((min_y / 2.0) + dy);

  on_button_clicked();

  ui->box_double_y->setValue((min_y / 2.0) - dy);

  on_button_clicked();



  ui->box_int_x->setValue(max_x / 4);

  ui->box_double_y->setValue((max_y / 2.0) + dy);

  on_button_clicked();

  ui->box_double_y->setValue((max_y / 2.0) - dy);

  on_button_clicked();



  ui->box_int_x->setValue(max_x / 2);

  ui->box_double_y->setValue((min_y / 2.0) + dy);

  on_button_clicked();

  ui->box_double_y->setValue((min_y / 2.0) - dy);

  on_button_clicked();



  ui->box_int_x->setValue(0);

  ui->box_double_y->setValue(0.0);

}



ribi::QtToolTestMultiApproximatorMainDialog::~QtToolTestMultiApproximatorMainDialog() noexcept

{

  delete ui;

}



void ribi::QtToolTestMultiApproximatorMainDialog::on_button_clicked() noexcept

{

  const int x = ui->box_int_x->value();

  const double y = ui->box_double_y->value();

  m_multi_approximator.Add(x,y);

  Plot();

}



void ribi::QtToolTestMultiApproximatorMainDialog::Plot() noexcept

{

  //Plot multi approximation

  {

    //Plot raw data

    {

      std::vector<double> xs;

      std::vector<double> ys;

      for (const auto p: m_multi_approximator.GetContainer())

      {

        xs.push_back( static_cast<double>(p.first) );

        ys.push_back( static_cast<double>(p.second) );

      }

      assert(m_curve_multi_values);

      #if QWT_VERSION >= 0x060000

      m_curve_multi_values->setData(new QwtPointArrayData(&xs[0],&ys[0],xs.size()));

      #else

      m_curve_values->setData(&xs[0],&y[0],xs.size());

      #endif

    }



    const double min_x = static_cast<double>(ui->box_int_x->minimum());

    const double max_x = static_cast<double>(ui->box_int_x->maximum());



    //Plot approximation

    {

      std::vector<double> xs;

      std::vector<double> ys;

      for (double t=min_x; t < max_x; t+=0.5)

      {

        try

        {

          const double x = static_cast<double>(t);

          const MultiApproximator_t::value_type y = m_multi_approximator.Approximate(x);

          ys.push_back(y);

          xs.push_back(x);

        }

        catch (ExceptionNoExtrapolation<MultiApproximator_t::key_type>& e)

        {



        }

      }

      assert(m_curve_multi_approximation);

      #if QWT_VERSION >= 0x060000

      m_curve_multi_approximation->setData(new QwtPointArrayData(&xs[0],&ys[0],xs.size()));

      #else

      m_curve_multi_approximation->setData(&xs[0],&y[0],xs.size());

      #endif

    }

    assert(m_multi_plot);

    m_multi_plot->replot();

  }

  //Plot (non-multi)approximation

  {

    //const Approximator<Key,Value,Container> approximator(

    const auto approximator(

      ToApproximator<Key,Value,MultiContainer,Container>(m_multi_approximator)

    );

    //Plot raw data

    {

      std::vector<double> xs;

      std::vector<double> ys;

      for (const auto p: approximator.Get())

      {

        xs.push_back( static_cast<double>(p.first) );

        ys.push_back( static_cast<double>(p.second) );

      }

      assert(m_curve_values);

      #if QWT_VERSION >= 0x060000

      m_curve_values->setData(new QwtPointArrayData(&xs[0],&ys[0],xs.size()));

      #else

      m_curve_values->setData(&xs[0],&y[0],xs.size());

      #endif

    }



    const double min_x = static_cast<double>(ui->box_int_x->minimum());

    const double max_x = static_cast<double>(ui->box_int_x->maximum());



    //Plot approximation

    {

      std::vector<double> xs;

      std::vector<double> ys;

      for (double t=min_x; t < max_x; t+=0.5)

      {

        try

        {

          const double x = static_cast<double>(t);

          const Approximator_t::value_type y = approximator.Approximate(x);

          ys.push_back(y);

          xs.push_back(x);

        }

        catch (ExceptionNoExtrapolation<Approximator_t::key_type>& e)

        {



        }

      }

      assert(m_curve_approximation);

      #if QWT_VERSION >= 0x060000

      m_curve_approximation->setData(new QwtPointArrayData(&xs[0],&ys[0],xs.size()));

      #else

      m_curve_approximation->setData(&xs[0],&y[0],xs.size());

      #endif

    }

    assert(m_plot);

    m_plot->replot();

  }

}



#ifndef NDEBUG

void ribi::QtToolTestMultiApproximatorMainDialog::Test() noexcept

{

  {

    static bool is_tested{false};

    if (is_tested) return;

    is_tested = true;

  }

  const TestTimer test_timer(__func__,__FILE__,1.0);

}

#endif

./ToolTestMultiApproximator/qttestmultiapproximatormenudialog.h


#ifndef QTTOOLTESTMULTIAPPROXIMATORMENUDIALOG_H

#define QTTOOLTESTMULTIAPPROXIMATORMENUDIALOG_H



#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#include "qthideandshowdialog.h"

#pragma GCC diagnostic pop



namespace Ui {

  class QtToolTestMultiApproximatorMenuDialog;

}



namespace ribi {



class QtToolTestMultiApproximatorMenuDialog : public QtHideAndShowDialog

{

  Q_OBJECT



public:

  explicit QtToolTestMultiApproximatorMenuDialog(QWidget *parent = 0) noexcept;

  QtToolTestMultiApproximatorMenuDialog(const QtToolTestMultiApproximatorMenuDialog&) = delete;

  QtToolTestMultiApproximatorMenuDialog& operator=(const QtToolTestMultiApproximatorMenuDialog&) = delete;

  ~QtToolTestMultiApproximatorMenuDialog() noexcept;



protected:

  void keyPressEvent(QKeyEvent * event) noexcept;



private:

  Ui::QtToolTestMultiApproximatorMenuDialog *ui;



private slots:

  void on_button_about_clicked() noexcept;

  void on_button_quit_clicked() noexcept;

  void on_button_start_clicked() noexcept;



  #ifndef NDEBUG

  static void Test() noexcept;

  #endif

};



} //~namespace ribi



#endif // QTTOOLTESTMULTIAPPROXIMATORMENUDIALOG_H

./ToolTestMultiApproximator/qttestmultiapproximatormenudialog.cpp


#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#include "qttestmultiapproximatormenudialog.h"



#include <QDesktopWidget>

#include <QKeyEvent>



#include "testmultiapproximatormenudialog.h"

#include "qtaboutdialog.h"

#include "qttestmultiapproximatormaindialog.h"

#include "qthideandshowdialog.h"

#include "testtimer.h"

#include "trace.h"

#include "ui_qttestmultiapproximatormenudialog.h"



#pragma GCC diagnostic pop



ribi::QtToolTestMultiApproximatorMenuDialog::QtToolTestMultiApproximatorMenuDialog(QWidget *parent) noexcept :

  QtHideAndShowDialog(parent),

  ui(new Ui::QtToolTestMultiApproximatorMenuDialog)

{

  #ifndef NDEBUG

  Test();

  #endif

  ui->setupUi(this);

}



ribi::QtToolTestMultiApproximatorMenuDialog::~QtToolTestMultiApproximatorMenuDialog() noexcept

{

  delete ui;

}



void ribi::QtToolTestMultiApproximatorMenuDialog::keyPressEvent(QKeyEvent * event) noexcept

{

  if (event->key() == Qt::Key_Escape) { close(); return; }

}



void ribi::QtToolTestMultiApproximatorMenuDialog::on_button_about_clicked() noexcept

{

  About a = ToolTestMultiApproximatorMenuDialog().GetAbout();

  a.AddLibrary("QtHideAndShowDialog version: " + QtHideAndShowDialog::GetVersion());

  QtAboutDialog d(a);

  d.setWindowIcon(this->windowIcon());

  d.setStyleSheet(this->styleSheet());

  this->ShowChild(&d);

}



void ribi::QtToolTestMultiApproximatorMenuDialog::on_button_quit_clicked() noexcept

{

  close();

}



void ribi::QtToolTestMultiApproximatorMenuDialog::on_button_start_clicked() noexcept

{

  QtToolTestMultiApproximatorMainDialog d;

  ShowChild(&d);

}



#ifndef NDEBUG

void ribi::QtToolTestMultiApproximatorMenuDialog::Test() noexcept

{

  {

    static bool is_tested{false};

    if (is_tested) return;

    is_tested = true;

  }

  QtToolTestMultiApproximatorMainDialog();

  const TestTimer test_timer(__func__,__FILE__,1.0);

}

#endif

./ToolTestMultiApproximator/testmultiapproximatormenudialog.h


#ifndef TOOLTESTMULTIAPPROXIMATORMENUDIALOG_H

#define TOOLTESTMULTIAPPROXIMATORMENUDIALOG_H



#include "menudialog.h"



namespace ribi {



struct ToolTestMultiApproximatorMenuDialog final : public MenuDialog

{

  About GetAbout() const noexcept override;

  Help GetHelp() const noexcept override;

  boost::shared_ptr<const Program> GetProgram() const noexcept override;

  std::string GetVersion() const noexcept override;

  std::vector<std::string> GetVersionHistory() const noexcept override;



  private:

  int ExecuteSpecific(const std::vector<std::string>& argv) noexcept override;



  #ifndef NDEBUG

  static void Test() noexcept;

  #endif

};



} //~namespace ribi



#endif // TOOLTESTMULTIAPPROXIMATORMENUDIALOG_H

./ToolTestMultiApproximator/testmultiapproximatormenudialog.cpp


#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#include "testmultiapproximatormenudialog.h"



#include <cassert>

#include <iostream>



#include "approximator.h"

#include "multiapproximator.h"

#include "richelbilderbeekprogram.h"

#include "testtimer.h"

#include "trace.h"



#pragma GCC diagnostic pop



int ribi::ToolTestMultiApproximatorMenuDialog::ExecuteSpecific(const std::vector<std::string>& argv) noexcept

{

  #ifndef NDEBUG

  Test();

  #endif

  const int argc = static_cast<int>(argv.size());

  if (argc == 1)

  {

    std::cout << GetHelp() << '\n';

    return 1;

  }

  assert(!"TODO");

  return 1;

}



ribi::About ribi::ToolTestMultiApproximatorMenuDialog::GetAbout() const noexcept

{

  About a(

    "Richel Bilderbeek",

    "ToolTestMultiApproximator",

    "tests the MultiApproximator class",

    "the 23rd of August 2013",

    "2013-2015",

    "http://www.richelbilderbeek.nl/ToolTestMultiApproximator.htm",

    GetVersion(),

    GetVersionHistory());

  a.AddLibrary("Approximator version: " + Approximator<>::GetVersion());

  a.AddLibrary("MultiApproximator version: " + MultiApproximator<>::GetVersion());

  a.AddLibrary("Trace version: " + Trace::GetVersion());

  return a;

}



ribi::Help ribi::ToolTestMultiApproximatorMenuDialog::GetHelp() const noexcept

{

  return Help(

    this->GetAbout().GetFileTitle(),

    this->GetAbout().GetFileDescription(),

    {



    },

    {



    }

  );

}



boost::shared_ptr<const ribi::Program> ribi::ToolTestMultiApproximatorMenuDialog::GetProgram() const noexcept

{

  const boost::shared_ptr<const Program> p {

    new ProgramTestMultiApproximator

  };

  assert(p);

  return p;

}



std::string ribi::ToolTestMultiApproximatorMenuDialog::GetVersion() const noexcept

{

  return "1.1";

}



std::vector<std::string> ribi::ToolTestMultiApproximatorMenuDialog::GetVersionHistory() const noexcept

{

  return {

    "2013-08-23: version 1.0: initial version",

    "2013-08-23: version 1.1: display conversion from MultiApproximator to Approximator"

  };

}



#ifndef NDEBUG

void ribi::ToolTestMultiApproximatorMenuDialog::Test() noexcept

{

  {

    static bool is_tested{false};

    if (is_tested) return;

    is_tested = true;

  }

  const TestTimer test_timer(__func__,__FILE__,1.0);

}

#endif

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

This page has been created by the tool CodeToHtml