File: mathclassifierstest.cc

package info (click to toggle)
dune-common 2.10.0-6
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid
  • size: 5,824 kB
  • sloc: cpp: 52,256; python: 3,979; sh: 1,658; makefile: 17
file content (69 lines) | stat: -rw-r--r-- 2,673 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#include <complex>
#include <iostream>
#include <limits>

#include <dune/common/math.hh>

int main() {
  //Initialize some variables
  int a = 42;
  const int b = 42;

  double nan = std::nan("");
  double inf = std::numeric_limits<double>::infinity();

  std::complex<double> complex_nonan(42., 42.);
  std::complex<double> complex_nan1(42.,nan);
  std::complex<double> complex_nan2(nan, 42.);
  std::complex<double> complex_nan3(nan, nan);

  std::complex<double> complex_noinf(42., 42.);
  std::complex<double> complex_inf1(42.,inf);
  std::complex<double> complex_inf2(inf, 42.);
  std::complex<double> complex_inf3(inf, inf);

  std::cout << std::boolalpha
            //check isNaN()
            << "isNaN(int): " << Dune::isNaN(a) << "\n"
            << "isNaN(const int): " << Dune::isNaN(b) << "\n"
            << "isNaN(42): " << Dune::isNaN(42) << "\n"
            << "isNaN(nan): " << Dune::isNaN(nan) << "\n"
            << "isNaN(inf): " << Dune::isNaN(inf) << "\n"

            << "isNaN(std::complex<double> without NaN): "
            << Dune::isNaN(complex_nonan) << "\n"
            << "isNaN(std::complex<double> with NaN): "
            << Dune::isNaN(complex_nan1) << " "
            << Dune::isNaN(complex_nan2) << " "
            << Dune::isNaN(complex_nan3) << "\n"

            //check isInf()
            << "isInf(int): " << Dune::isInf(a) << "\n"
            << "isInf(const int): " << Dune::isInf(b) << "\n"
            << "isInf(42): " << Dune::isInf(42) << "\n"
            << "isInf(inf): " << Dune::isInf(inf) << "\n"

            << "isInf(std::complex<double> without inf): "
            << Dune::isInf(complex_noinf) << "\n"
            << "isInf(std::complex<double> with inf): "
            << Dune::isInf(complex_inf1) << " "
            << Dune::isInf(complex_inf2) << " "
            << Dune::isInf(complex_inf3) << "\n"

            //check isFinite()
            << "isFinite(int): " << Dune::isFinite(a) << "\n"
            << "isFinite(const int): " << Dune::isFinite(b) << "\n"
            << "isFinite(42): " << Dune::isFinite(42) << "\n"
            << "isFinite(inf): " << Dune::isFinite(inf) << "\n"

            << "isFinite(std::complex<double> without inf): "
            << Dune::isFinite(complex_noinf) << "\n"
            << "isFinite(std::complex<double> with inf): "
            << Dune::isFinite(complex_inf1) << " "
            << Dune::isFinite(complex_inf2) << " "
            << Dune::isFinite(complex_inf3) << "\n"

  << std::endl;
}