struct X4
{
constexpr operator double() const { return 1.0; }
};
struct X5
{
constexpr operator int() const { return __INT_MAX__; }
constexpr operator unsigned() const { return __INT_MAX__ * 2U + 1; }
};
enum E0 { e0 = X0() };
enum E1 { e1 = X1() };
enum E2 { e2 = X2() };
enum E3 { e3 = X3() };
enum E4 { e4 = X4() }; // { dg-error "integer constant" }
enum E5 { e5 = X5() }; // { dg-error "ambiguous" }
enum F0 : int { f0 = X0() };
enum F1 : int { f1 = X1() };
enum F2 : int { f2 = X2() };
enum F3 : int { f3 = X3() };
enum F4 : int { f4 = X4() }; // { dg-error "narrowing" }
enum F5 : int { f5 = X5() };
enum G0 : signed char { g0 = X0() };
enum G1 : signed char { g1 = X1() };
enum G2 : signed char { g2 = X2() }; // { dg-error "narrowing" }
enum G3 : signed char { g3 = X3() }; // { dg-error "narrowing" }
enum G4 : signed char { g4 = X4() }; // { dg-error "narrowing" }
enum G5 : signed char { g5 = X5() }; // { dg-error "ambiguous" }
/*
* Translate current exceptions into `first' exception. The
* bits go the wrong way for ffs() (0x10 is most important, etc).
* There are only 5, so do it the obvious way.
*/
#define X1(x) x
#define X2(x) x,x
#define X4(x) x,x,x,x
#define X8(x) X4(x),X4(x)
#define X16(x) X8(x),X8(x)
static char cx_to_trapx[] = {
X1(FSR_NX),
X2(FSR_DZ),
X4(FSR_UF),
X8(FSR_OF),
X16(FSR_NV)
};
static u_char fpu_codes[] = {
X1(FPE_FLTINEX_TRAP),
X2(FPE_FLTDIV_TRAP),
X4(FPE_FLTUND_TRAP),
X8(FPE_FLTOVF_TRAP),
X16(FPE_FLTOPERR_TRAP)
};
static int fpu_types[] = {
X1(FPE_FLTRES),
X2(FPE_FLTDIV),
X4(FPE_FLTUND),
bool
test_fundamentals(Index const dimension)
{
bool
passed = true;
Index const
number_components = integer_power(dimension, Tensor::ORDER);
std::vector<Scalar> const
X = generate_sequence<Scalar>(number_components, 1.0, 1.0);
// Test constructor with pointer
Tensor const
A(dimension, &X[0]);
// Test copy constructor
Tensor
B = A;
Tensor
C;
// Test copy assignment
C = B - A;
Scalar
error = norm_f(C);
bool const
copy_assigned = error <= machine_epsilon<Scalar>();
passed = passed && copy_assigned;
// Test fill with pointer
B.fill(&X[0]);
C = B - A;
error = norm_f(C);
bool const
filled_pointer = error <= machine_epsilon<Scalar>();
passed = passed && filled_pointer;
std::vector<Scalar> const
Y = generate_sequence<Scalar>(number_components, -1.0, -1.0);
C.fill(&Y[0]);
// Test increment
C += A;
error = norm_f(C);
bool const
incremented = error <= machine_epsilon<Scalar>();
passed = passed && incremented;
C.fill(&X[0]);
// Test decrement
C -= A;
error = norm_f(C);
bool const
decremented = error <= machine_epsilon<Scalar>();
passed = passed && decremented;
#ifdef HAVE_INTREPID_KOKKOSCORE
//test Tensor fill and create for Kokkos data types
Kokkos::View<Scalar *, Kokkos::DefaultExecutionSpace>
X1("X1_kokkos", dimension);
Kokkos::View<Scalar **, Kokkos::DefaultExecutionSpace>
X2("X2_kokkos", dimension, dimension);
Kokkos::View<Scalar ***, Kokkos::DefaultExecutionSpace>
X3("X3_kokkos", dimension, dimension, dimension);
Kokkos::View<Scalar ****, Kokkos::DefaultExecutionSpace>
X4("X4_kokkos", dimension, dimension, dimension, dimension);
Kokkos::deep_copy(X1, 3.1);
Kokkos::deep_copy(X2, 3.2);
Kokkos::deep_copy(X3, 3.3);
Kokkos::deep_copy(X4, 3.4);
Tensor
Z(dimension); //(X1_k,0);
Index
rank = 0;
Index
temp = number_components;
while (temp != 1) {
temp = temp / dimension;
rank = rank + 1;
assert(temp > 0);
}
switch (rank) {
default:
assert(false);
break;
case 1:
Z.fill(X1, 0);
break;
case 2:
Z.fill(X2, 0, 0);
break;
case 3:
Z.fill(X3, 0, 0, 0);
break;
case 4:
Z.fill(X4, 0, 0, 0, 0);
break;
}
// Test copy constructor.
Tensor const
U = Z;
// Test copy assignment.
Tensor
V;
V = U - Z;
error = norm_f(V);
bool const
tensor_create_from_1d_kokkos = error <= machine_epsilon<Scalar>();
passed = passed && tensor_create_from_1d_kokkos;
#endif
return passed;
}
