Functions
SmallVectorUnitTest.cpp File Reference
#include <iostream>
#include <cstdlib>
#include <cmath>
#include "Math/SmallVector.h"
#include "Logger.h"

Functions

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

Function Documentation

◆ main()

int main ( int argc  ,
char *  argv[] 
)
35 {
36  //(operator[], operator() and size() don't have a stand-alone test, but are used throughout the test in multiple assertions
37 
38  //various constructors
39  double data[] = {1., 2., 3.};
40  SmallVector<0> x0;
41  SmallVector<1> x1, y1(x1);
42  SmallVector<3> fromArray(data);
43  SmallVector<4> destroy, convenient({5.,6.,8.,9.});
44  data[0] = 4;
45  logger.assert_always(x0.size() == 0, "Constructor creates a vector of the wrong size");
46  logger.assert_always(x1.size() == 1, "Constructor creates a vector of the wrong size");
47  logger.assert_always(y1.size() == 1, "Constructor creates a vector of the wrong size");
48  logger.assert_always(y1 == x1, "Copied array does not pass equality test");
49  logger.assert_always(std::abs(y1[0] - x1[0]) < 1e-12, "Copy constructor does not copy values");
50  logger.assert_always(destroy.size() == 4, "Constructor creates a vector of the wrong size");
51  logger.assert_always(convenient.size() == 4, "Constructor creates a vector of the wrong size");
52  logger.assert_always(fromArray.size() == 3, "Constructor creates a vector of the wrong size");
53  destroy[2] = 4;
54  SmallVector<4> moved(std::move(destroy));
55  logger.assert_always(moved.size() == 4, "Constructor creates a vector of the wrong size");
56  logger.assert_always(std::abs(moved[2] - 4.) < 1e-12, "Constructor from array does not copy!");
57  logger.assert_always(std::abs(fromArray(0) - 1.) < 1e-12, "Constructor from array does not copy!");
58  logger.assert_always(std::abs(fromArray(1) - 2.) < 1e-12, "Constructor from array does not copy!");
59  logger.assert_always(std::abs(fromArray[2] - 3.) < 1e-12, "Constructor from array does not copy!");
60  logger.assert_always(std::abs(convenient[0] - 5.) < 1e-12, "Initializer list constructor does not copy!");
61  logger.assert_always(std::abs(convenient[1] - 6.) < 1e-12, "Initializer list constructor does not copy!");
62  logger.assert_always(std::abs(convenient[2] - 8.) < 1e-12, "Initializer list constructor does not copy!");
63  logger.assert_always(std::abs(convenient[3] - 9.) < 1e-12, "Initializer list constructor does not copy!");
64  SmallVector<4> assigned = moved;
65  logger.assert_always(assigned.size() == 4, "Constructor creates a vector of the wrong size");
66  logger.assert_always(std::abs(assigned[2] - 4.) < 1e-12, "Constructor from array does not copy!");
67  destroy = convenient;
68  logger.assert_always(destroy.size() == 4, "Assignment operator creates a vector of the wrong size");
69  logger.assert_always(std::abs(convenient(0) - 5.) < 1e-12, "Assignment operator from array does not copy!");
70  logger.assert_always(std::abs(convenient[1] - 6.) < 1e-12, "Assignment operator from array does not copy!");
71  logger.assert_always(std::abs(convenient(2) - 8.) < 1e-12, "Assignment operator from array does not copy!");
72  logger.assert_always(std::abs(convenient(3) - 9.) < 1e-12, "Assignment operator from array does not copy!");
73 
74  SmallVector<2> p2 = {{0.8, 1.8}};
75  SmallVector<2> pc2;
76  SmallVector<2> pv2 = {{0.8, 0.8}};
77  SmallVector<2> pw2 = {{1.8, 1.8}};
78  SmallVector<2> px2 = {{1.8, 0.8}};
79  SmallVector<2> py2 = {{0.6, 0.7}};
80  const SmallVector<2> pr2 = pc2 = p2;
81  logger.assert_always(pr2.size() == 2, "Constructor creates a vector of the wrong size");
82  logger.assert_always(pc2.size() == 2, "Constructor creates a vector of the wrong size");
83  for (std::size_t i = 0; i < 2; ++i)
84  {
85  logger.assert_always((std::abs(pc2[i] - 0.8 - i) < 1e-12), "assignment operator");
86  logger.assert_always((std::abs(pr2[i] - 0.8 - i) < 1e-12), "assignment operator");
87  }
88  logger.assert_always((pr2 == pc2 && pc2 == pr2 && pc2 == p2 && !(pr2 == pv2 || pv2 == pr2 || p2 == pv2)), "equality operator");
89  logger.assert_always(!(pr2 == pw2 || pw2 == pr2 || p2 == pw2 || pr2 == px2 || px2 == pr2 || p2 == px2 || pr2 == py2 || py2 == pr2 || p2 == py2), "equality operator");
90  pc2 += p2;
91  for (std::size_t i = 0; i < 2; ++i)
92  {
93  logger.assert_always((std::abs(pc2[i] - 1.6 - 2 * i) < 1e-12), "increment operator");
94  }
95  pc2 -= pv2;
96  for (std::size_t i = 0; i < 2; ++i)
97  {
98  logger.assert_always((std::abs(pc2[i] - 0.8 - 2 * i) < 1e-12), "decrement operator");
99  }
100  pc2 *= 4.;
101  for (std::size_t i = 0; i < 2; ++i)
102  {
103  logger.assert_always((std::abs(pc2[i] - 3.2 - 8 * i) < 1e-12), "multiply operator");
104  }
105  for (std::size_t i = 0; i < 2; ++i)
106  {
107  logger.assert_always((std::abs((pc2 * -0.25)[i] + 0.8 + 2 * i) < 1e-12), "multiplication");
108  }
109  for (std::size_t i = 0; i < 2; ++i)
110  {
111  logger.assert_always((std::abs((pc2 + pv2)[i] - 4. - 8 * i) < 1e-12), "addition");
112  }
113  for (std::size_t i = 0; i < 2; ++i)
114  {
115  logger.assert_always((std::abs((pv2 - pc2)[i] + 2.4 + 8 * i) < 1e-12), "subtraction");
116  }
117  for (std::size_t i = 0; i < 2; ++i)
118  {
119  logger.assert_always((std::abs((-pc2)[i] + 3.2 + 8 * i) < 1e-12), "unary -");
120  }
121  for (std::size_t i = 0; i < 2; ++i)
122  {
123  logger.assert_always((std::abs((0.25 * pc2)[i] - 0.8 - 2 * i) < 1e-12), "left multiplication");
124  }
125  logger.assert_always((std::abs((pv2 * pc2) - 1.44 * 8) < 1e-12), "in-product");
126  pc2 /= 4.;
127  for (std::size_t i = 0; i < 2; ++i)
128  {
129  logger.assert_always((std::abs(pc2[i] - 0.8 - 2 * i) < 1e-12), "divide operator");
130  }
131  for (std::size_t i = 0; i < 2; ++i)
132  {
133  logger.assert_always((std::abs((pc2 / -0.25)[i] + 3.2 + 8 * i) < 1e-12), "division");
134  }
135  pc2.axpy(-3., p2);
136  for (std::size_t i = 0; i < 2; ++i)
137  {
138  logger.assert_always((std::abs(pc2[i] + 1.6 + i) < 1e-12), "combined multiply and addition (y = ax + y)");
139  }
140 
141  x0.data();
142 
143  SmallVector<4> magicCopy(convenient.data());
144  logger.assert_always(std::abs(magicCopy(0) - 5.) < 1e-12, "Assignment operator from array does not copy!");
145  logger.assert_always(std::abs(magicCopy(1) - 6.) < 1e-12, "Assignment operator from array does not copy!");
146  logger.assert_always(std::abs(magicCopy(2) - 8.) < 1e-12, "Assignment operator from array does not copy!");
147  logger.assert_always(std::abs(magicCopy(3) - 9.) < 1e-12, "Assignment operator from array does not copy!");
148  convenient.data()[3] = 2.;
149  logger.assert_always(std::abs(magicCopy(3) - 9.) < 1e-12, "Assignment operator from array does not copy!");
150  logger.assert_always(std::abs(convenient(3) - 2.) < 1e-12, "Assignment operator from array does not copy!");
151 
152 
153  logger(INFO, "%%", pc2, convenient);
154  return 0;
155 }
abs
AnnoyingScalar abs(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:135
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
e
Array< double, 1, 3 > e(1./3., 0.5, 2.)
logger
Logger< MERCURYDPM_LOGLEVEL > logger("MercuryKernel")
Definition of different loggers with certain modules. A user can define its own custom logger here.
data
int data[]
Definition: Map_placement_new.cpp:1
SmallVector
Definition: SmallVector.h:42
SmallVector::size
unsigned int size() const
Definition: SmallVector.h:213
INFO
#define INFO(i)
Definition: mumps_solver.h:54
Global_parameters::x1
Vector< double > x1(const Vector< double > &coord)
Cartesian coordinates centered at the point (0.5,1)
Definition: poisson/poisson_with_singularity/two_d_poisson.cc:86
Global::x0
Vector< double > x0(2, 0.0)

References abs(), SmallVector< numberOfRows >::axpy(), data, e(), i, INFO, logger, SmallVector< numberOfRows >::size(), Global::x0, and Global_parameters::x1().