Rename tests for AlignedVector as aligned_vector_xx, add a test for a bool vector

git-svn-id: https://svn.dealii.org/trunk@32746 0785d39b-7218-0410-832d-ea1e28bc413d

diff --git a/tests/base/aligned_vector_01.cc b/tests/base/aligned_vector_01.cc
new file mode 100644 (file)
index 0000000..b2a1026
--- /dev/null
+++ b/tests/base/aligned_vector_01.cc
@@ -0,0 +1,101 @@
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2012 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+
+// test for AlignedVector<unsigned int> which tests the basic stuff in the
+// aligned vector
+
+#include "../tests.h"
+#include <iomanip>
+#include <fstream>
+#include <cmath>
+
+#include <deal.II/base/aligned_vector.h>
+
+
+void test ()
+{
+  typedef AlignedVector<unsigned int> VEC;
+  VEC a(4);
+  deallog << "Constructor: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a[2] = 1;
+  a.push_back (5);
+  a.push_back (42);
+
+  VEC b (a);
+  b.push_back (27);
+  a.insert_back (b.begin(), b.end());
+
+  deallog << "Insertion: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a.resize(4);
+  deallog << "Shrinking: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a.reserve(100);
+  deallog << "Reserve: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a = b;
+  deallog << "Assignment: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  // check setting elements for large vectors
+  a.resize (0);
+  a.resize (100000, 1);
+  deallog << "Check large initialization: ";
+  for (unsigned int i=0; i<100000; ++i)
+    AssertDimension (a[i], 1);
+  deallog << "OK" << std::endl;
+
+  // check resize for large vectors
+  deallog << "Check large resize: ";
+  a.resize (200000, 2);
+  a.resize (400000);
+  for (unsigned int i=0; i<100000; ++i)
+    AssertDimension (a[i], 1);
+  for (unsigned int i=100000; i<200000; ++i)
+    AssertDimension (a[i], 2);
+  for (unsigned int i=200000; i<400000; ++i)
+    AssertDimension (a[i], 0);
+  deallog << "OK" << std::endl;
+}
+
+
+
+
+int main()
+{
+  std::ofstream logfile("output");
+  deallog.attach(logfile);
+  deallog.depth_console(0);
+  deallog.threshold_double(1.e-10);
+
+  test ();
+}

diff --git a/tests/base/aligned_vector_01.output b/tests/base/aligned_vector_01.output
new file mode 100644 (file)
index 0000000..1b934a8
--- /dev/null
+++ b/tests/base/aligned_vector_01.output
@@ -0,0 +1,8 @@
+
+DEAL::Constructor: 0 0 0 0 
+DEAL::Insertion: 0 0 1 0 5 42 0 0 1 0 5 42 27 
+DEAL::Shrinking: 0 0 1 0 
+DEAL::Reserve: 0 0 1 0 
+DEAL::Assignment: 0 0 1 0 5 42 27 
+DEAL::Check large initialization: OK
+DEAL::Check large resize: OK

diff --git a/tests/base/vectorization_03.cc b/tests/base/aligned_vector_02.cc
similarity index 100%
rename from tests/base/vectorization_03.cc
rename to tests/base/aligned_vector_02.cc

diff --git a/tests/base/vectorization_03.output b/tests/base/aligned_vector_02.output
similarity index 100%
rename from tests/base/vectorization_03.output
rename to tests/base/aligned_vector_02.output

diff --git a/tests/base/aligned_vector_03.cc b/tests/base/aligned_vector_03.cc
new file mode 100644 (file)
index 0000000..9cfbd5c
--- /dev/null
+++ b/tests/base/aligned_vector_03.cc
@@ -0,0 +1,103 @@
+// ---------------------------------------------------------------------
+// $Id$
+//
+// Copyright (C) 2012 - 2013 by the deal.II authors
+//
+// This file is part of the deal.II library.
+//
+// The deal.II library is free software; you can use it, redistribute
+// it, and/or modify it under the terms of the GNU Lesser General
+// Public License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+// The full text of the license can be found in the file LICENSE at
+// the top level of the deal.II distribution.
+//
+// ---------------------------------------------------------------------
+
+
+// test for AlignedVector<bool>
+
+#include "../tests.h"
+#include <iomanip>
+#include <fstream>
+#include <cmath>
+
+#include <deal.II/base/aligned_vector.h>
+
+
+void test ()
+{
+  typedef AlignedVector<bool> VEC;
+  VEC a(4);
+  deallog << "Constructor: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a[2] = true;
+  a.push_back (true);
+  a.push_back (false);
+
+  VEC b (a);
+  b.push_back (true);
+  a.insert_back (b.begin(), b.end());
+
+  deallog << "Insertion: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a.resize(4);
+  deallog << "Shrinking: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a.reserve(100);
+  deallog << "Reserve: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  a = b;
+  deallog << "Assignment: ";
+  for (unsigned int i=0; i<a.size(); ++i)
+    deallog << a[i] << " ";
+  deallog << std::endl;
+
+  // check setting elements for large vectors
+  a.resize (0);
+  a.resize (100000, true);
+  deallog << "Check large initialization: ";
+  for (unsigned int i=0; i<100000; ++i)
+    AssertDimension (a[i], true);
+  deallog << "OK" << std::endl;
+
+  // check resize for large vectors
+  deallog << "Check large resize: ";
+  a.resize (200000, false);
+  a.resize (400000, true);
+  for (unsigned int i=0; i<100000; ++i)
+    AssertDimension (a[i], true);
+  for (unsigned int i=100000; i<200000; ++i)
+    AssertDimension (a[i], false);
+  for (unsigned int i=200000; i<400000; ++i)
+    AssertDimension (a[i], true);
+  deallog << "OK" << std::endl;
+
+  deallog << "Memory consumption: " << a.memory_consumption()
+          << " for a.size()=" << a.size() << std::endl;
+}
+
+
+
+
+int main()
+{
+  std::ofstream logfile("output");
+  deallog.attach(logfile);
+  deallog.depth_console(0);
+  deallog.threshold_double(1.e-10);
+
+  test ();
+}

diff --git a/tests/base/aligned_vector_03.output b/tests/base/aligned_vector_03.output
new file mode 100644 (file)
index 0000000..1b934a8
--- /dev/null
+++ b/tests/base/aligned_vector_03.output
@@ -0,0 +1,8 @@
+
+DEAL::Constructor: 0 0 0 0 
+DEAL::Insertion: 0 0 1 0 5 42 0 0 1 0 5 42 27 
+DEAL::Shrinking: 0 0 1 0 
+DEAL::Reserve: 0 0 1 0 
+DEAL::Assignment: 0 0 1 0 5 42 27 
+DEAL::Check large initialization: OK
+DEAL::Check large resize: OK

diff --git a/tests/base/vectorization_01.cc b/tests/base/vectorization_01.cc
index b2a10264158a6298aeb8b1aa344a76b94bf6a69c..bb2e43046f2e250f90d2ef0a32b012887adcb11b 100644 (file)
--- a/tests/base/vectorization_01.cc
+++ b/tests/base/vectorization_01.cc
@@ -15,75 +15,133 @@
 // ---------------------------------------------------------------------
 
 
-// test for AlignedVector<unsigned int> which tests the basic stuff in the
-// aligned vector
+// test for arithmetic operations on VectorizedArray
 
 #include "../tests.h"
 #include <iomanip>
-#include <fstream>
-#include <cmath>
+#include <limits>
 
-#include <deal.II/base/aligned_vector.h>
+#include <deal.II/base/vectorization.h>
 
 
+template <typename Number>
 void test ()
 {
-  typedef AlignedVector<unsigned int> VEC;
-  VEC a(4);
-  deallog << "Constructor: ";
-  for (unsigned int i=0; i<a.size(); ++i)
-    deallog << a[i] << " ";
-  deallog << std::endl;
-
-  a[2] = 1;
-  a.push_back (5);
-  a.push_back (42);
-
-  VEC b (a);
-  b.push_back (27);
-  a.insert_back (b.begin(), b.end());
-
-  deallog << "Insertion: ";
-  for (unsigned int i=0; i<a.size(); ++i)
-    deallog << a[i] << " ";
-  deallog << std::endl;
-
-  a.resize(4);
-  deallog << "Shrinking: ";
-  for (unsigned int i=0; i<a.size(); ++i)
-    deallog << a[i] << " ";
-  deallog << std::endl;
-
-  a.reserve(100);
-  deallog << "Reserve: ";
-  for (unsigned int i=0; i<a.size(); ++i)
-    deallog << a[i] << " ";
-  deallog << std::endl;
-
-  a = b;
-  deallog << "Assignment: ";
-  for (unsigned int i=0; i<a.size(); ++i)
-    deallog << a[i] << " ";
-  deallog << std::endl;
-
-  // check setting elements for large vectors
-  a.resize (0);
-  a.resize (100000, 1);
-  deallog << "Check large initialization: ";
-  for (unsigned int i=0; i<100000; ++i)
-    AssertDimension (a[i], 1);
-  deallog << "OK" << std::endl;
-
-  // check resize for large vectors
-  deallog << "Check large resize: ";
-  a.resize (200000, 2);
-  a.resize (400000);
-  for (unsigned int i=0; i<100000; ++i)
-    AssertDimension (a[i], 1);
-  for (unsigned int i=100000; i<200000; ++i)
-    AssertDimension (a[i], 2);
-  for (unsigned int i=200000; i<400000; ++i)
-    AssertDimension (a[i], 0);
+  // since the number of array elements is system dependent, it is not a good
+  // idea to print them to an output file. Instead, check the values manually
+  VectorizedArray<Number> a, b, c;
+  const unsigned int n_vectors = VectorizedArray<Number>::n_array_elements;
+  a = Number(2.);
+  b = Number(-1.);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    c[i] = i;
+
+  deallog << "Addition: ";
+  VectorizedArray<Number> d = a + b;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == 1, ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Subtraction: ";
+  VectorizedArray<Number> e = d - b;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (e[i] == a[i], ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Multiplication: ";
+  d = a * c;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == a[i] * c[i], ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Division: ";
+  e = d / a;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (e[i] == c[i], ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Multiplication scalar: ";
+  a = 2. * a;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (a[i] == 4., ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Division scalar left: ";
+  d = 1. / a;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == 0.25, ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Division scalar right: ";
+  e = d / 0.25;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (e[i] == 1, ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Unary operator -: ";
+  d = -c;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == -(Number)i, ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Unary operator +: ";
+  d = c;
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == i, ExcInternalError());
+
+
+  deallog << "OK" << std::endl
+          << "Square root: ";
+  d = std::sqrt(c);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (std::fabs(d[i]-std::sqrt(Number(i)))<
+            std::numeric_limits<Number>::epsilon(),
+            ExcInternalError());
+
+  deallog << "OK" << std::endl
+          << "Absolute value: ";
+  d = -c;
+  d = std::abs(d);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == Number(i), ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Maximum value: ";
+  d = std::max(a, c);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == std::max(a[i], c[i]), ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Minimum value: ";
+  d = std::min(0.5 * a + b, c);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (d[i] == std::min(Number(0.5 * a[i] + b[i]), c[i]), ExcInternalError());
+
+  deallog << "OK" << std::endl
+          << "Sine: ";
+  e = std::sin(b);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (std::fabs(e[i]-std::sin(b[i])) <
+            10.*std::numeric_limits<Number>::epsilon(),
+            ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Cosine: ";
+  e = std::cos(c);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (std::fabs(e[i]-std::cos(c[i])) <
+            10.*std::numeric_limits<Number>::epsilon(),
+            ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Tangent: ";
+  d = std::tan(e);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (std::fabs(d[i]-std::tan(e[i])) <
+            10.*std::numeric_limits<Number>::epsilon(),
+            ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Exponential: ";
+  d = std::exp(c-a);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (std::fabs(d[i]-std::exp(c[i]-a[i])) <
+            10.*std::numeric_limits<Number>::epsilon(),
+            ExcInternalError());
+  deallog << "OK" << std::endl
+          << "Logarithm: ";
+  e = std::log(d);
+  for (unsigned int i=0; i<n_vectors; ++i)
+    Assert (std::fabs(e[i]-(c[i]-a[i])) <
+            10.*std::numeric_limits<Number>::epsilon(),
+            ExcInternalError());
   deallog << "OK" << std::endl;
 }
 
@@ -97,5 +155,17 @@ int main()
   deallog.depth_console(0);
   deallog.threshold_double(1.e-10);
 
-  test ();
+  deallog.push("double");
+  test<double> ();
+  deallog.pop();
+  deallog.push("float");
+  test<float> ();
+  deallog.pop();
+
+  // test long double: in that case, the default
+  // path of VectorizedArray is taken no matter
+  // what was done for double or float
+  deallog.push("long double");
+  test<float> ();
+  deallog.pop();
 }

diff --git a/tests/base/vectorization_01.output b/tests/base/vectorization_01.output
index 1b934a82996c3f22536b42f0baca1020bb50822c..c11369e533ce76c249e86977f31561e612c8d011 100644 (file)
--- a/tests/base/vectorization_01.output
+++ b/tests/base/vectorization_01.output
@@ -1,8 +1,55 @@
 
-DEAL::Constructor: 0 0 0 0 
-DEAL::Insertion: 0 0 1 0 5 42 0 0 1 0 5 42 27 
-DEAL::Shrinking: 0 0 1 0 
-DEAL::Reserve: 0 0 1 0 
-DEAL::Assignment: 0 0 1 0 5 42 27 
-DEAL::Check large initialization: OK
-DEAL::Check large resize: OK
+DEAL:double::Addition: OK
+DEAL:double::Subtraction: OK
+DEAL:double::Multiplication: OK
+DEAL:double::Division: OK
+DEAL:double::Multiplication scalar: OK
+DEAL:double::Division scalar left: OK
+DEAL:double::Division scalar right: OK
+DEAL:double::Unary operator -: OK
+DEAL:double::Unary operator +: OK
+DEAL:double::Square root: OK
+DEAL:double::Absolute value: OK
+DEAL:double::Maximum value: OK
+DEAL:double::Minimum value: OK
+DEAL:double::Sine: OK
+DEAL:double::Cosine: OK
+DEAL:double::Tangent: OK
+DEAL:double::Exponential: OK
+DEAL:double::Logarithm: OK
+DEAL:float::Addition: OK
+DEAL:float::Subtraction: OK
+DEAL:float::Multiplication: OK
+DEAL:float::Division: OK
+DEAL:float::Multiplication scalar: OK
+DEAL:float::Division scalar left: OK
+DEAL:float::Division scalar right: OK
+DEAL:float::Unary operator -: OK
+DEAL:float::Unary operator +: OK
+DEAL:float::Square root: OK
+DEAL:float::Absolute value: OK
+DEAL:float::Maximum value: OK
+DEAL:float::Minimum value: OK
+DEAL:float::Sine: OK
+DEAL:float::Cosine: OK
+DEAL:float::Tangent: OK
+DEAL:float::Exponential: OK
+DEAL:float::Logarithm: OK
+DEAL:long double::Addition: OK
+DEAL:long double::Subtraction: OK
+DEAL:long double::Multiplication: OK
+DEAL:long double::Division: OK
+DEAL:long double::Multiplication scalar: OK
+DEAL:long double::Division scalar left: OK
+DEAL:long double::Division scalar right: OK
+DEAL:long double::Unary operator -: OK
+DEAL:long double::Unary operator +: OK
+DEAL:long double::Square root: OK
+DEAL:long double::Absolute value: OK
+DEAL:long double::Maximum value: OK
+DEAL:long double::Minimum value: OK
+DEAL:long double::Sine: OK
+DEAL:long double::Cosine: OK
+DEAL:long double::Tangent: OK
+DEAL:long double::Exponential: OK
+DEAL:long double::Logarithm: OK

diff --git a/tests/base/vectorization_04.cc b/tests/base/vectorization_04.cc
deleted file mode 100644 (file)
index bb2e430..0000000
--- a/tests/base/vectorization_04.cc
+++ /dev/null
@@ -1,171 +0,0 @@
-// ---------------------------------------------------------------------
-// $Id$
-//
-// Copyright (C) 2012 - 2013 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-
-// test for arithmetic operations on VectorizedArray
-
-#include "../tests.h"
-#include <iomanip>
-#include <limits>
-
-#include <deal.II/base/vectorization.h>
-
-
-template <typename Number>
-void test ()
-{
-  // since the number of array elements is system dependent, it is not a good
-  // idea to print them to an output file. Instead, check the values manually
-  VectorizedArray<Number> a, b, c;
-  const unsigned int n_vectors = VectorizedArray<Number>::n_array_elements;
-  a = Number(2.);
-  b = Number(-1.);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    c[i] = i;
-
-  deallog << "Addition: ";
-  VectorizedArray<Number> d = a + b;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == 1, ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Subtraction: ";
-  VectorizedArray<Number> e = d - b;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (e[i] == a[i], ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Multiplication: ";
-  d = a * c;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == a[i] * c[i], ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Division: ";
-  e = d / a;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (e[i] == c[i], ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Multiplication scalar: ";
-  a = 2. * a;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (a[i] == 4., ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Division scalar left: ";
-  d = 1. / a;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == 0.25, ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Division scalar right: ";
-  e = d / 0.25;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (e[i] == 1, ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Unary operator -: ";
-  d = -c;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == -(Number)i, ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Unary operator +: ";
-  d = c;
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == i, ExcInternalError());
-
-
-  deallog << "OK" << std::endl
-          << "Square root: ";
-  d = std::sqrt(c);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(d[i]-std::sqrt(Number(i)))<
-            std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
-
-  deallog << "OK" << std::endl
-          << "Absolute value: ";
-  d = -c;
-  d = std::abs(d);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == Number(i), ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Maximum value: ";
-  d = std::max(a, c);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == std::max(a[i], c[i]), ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Minimum value: ";
-  d = std::min(0.5 * a + b, c);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (d[i] == std::min(Number(0.5 * a[i] + b[i]), c[i]), ExcInternalError());
-
-  deallog << "OK" << std::endl
-          << "Sine: ";
-  e = std::sin(b);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(e[i]-std::sin(b[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Cosine: ";
-  e = std::cos(c);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(e[i]-std::cos(c[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Tangent: ";
-  d = std::tan(e);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(d[i]-std::tan(e[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Exponential: ";
-  d = std::exp(c-a);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(d[i]-std::exp(c[i]-a[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
-  deallog << "OK" << std::endl
-          << "Logarithm: ";
-  e = std::log(d);
-  for (unsigned int i=0; i<n_vectors; ++i)
-    Assert (std::fabs(e[i]-(c[i]-a[i])) <
-            10.*std::numeric_limits<Number>::epsilon(),
-            ExcInternalError());
-  deallog << "OK" << std::endl;
-}
-
-
-
-
-int main()
-{
-  std::ofstream logfile("output");
-  deallog.attach(logfile);
-  deallog.depth_console(0);
-  deallog.threshold_double(1.e-10);
-
-  deallog.push("double");
-  test<double> ();
-  deallog.pop();
-  deallog.push("float");
-  test<float> ();
-  deallog.pop();
-
-  // test long double: in that case, the default
-  // path of VectorizedArray is taken no matter
-  // what was done for double or float
-  deallog.push("long double");
-  test<float> ();
-  deallog.pop();
-}

diff --git a/tests/base/vectorization_04.output b/tests/base/vectorization_04.output
deleted file mode 100644 (file)
index c11369e..0000000
--- a/tests/base/vectorization_04.output
+++ /dev/null
@@ -1,55 +0,0 @@
-
-DEAL:double::Addition: OK
-DEAL:double::Subtraction: OK
-DEAL:double::Multiplication: OK
-DEAL:double::Division: OK
-DEAL:double::Multiplication scalar: OK
-DEAL:double::Division scalar left: OK
-DEAL:double::Division scalar right: OK
-DEAL:double::Unary operator -: OK
-DEAL:double::Unary operator +: OK
-DEAL:double::Square root: OK
-DEAL:double::Absolute value: OK
-DEAL:double::Maximum value: OK
-DEAL:double::Minimum value: OK
-DEAL:double::Sine: OK
-DEAL:double::Cosine: OK
-DEAL:double::Tangent: OK
-DEAL:double::Exponential: OK
-DEAL:double::Logarithm: OK
-DEAL:float::Addition: OK
-DEAL:float::Subtraction: OK
-DEAL:float::Multiplication: OK
-DEAL:float::Division: OK
-DEAL:float::Multiplication scalar: OK
-DEAL:float::Division scalar left: OK
-DEAL:float::Division scalar right: OK
-DEAL:float::Unary operator -: OK
-DEAL:float::Unary operator +: OK
-DEAL:float::Square root: OK
-DEAL:float::Absolute value: OK
-DEAL:float::Maximum value: OK
-DEAL:float::Minimum value: OK
-DEAL:float::Sine: OK
-DEAL:float::Cosine: OK
-DEAL:float::Tangent: OK
-DEAL:float::Exponential: OK
-DEAL:float::Logarithm: OK
-DEAL:long double::Addition: OK
-DEAL:long double::Subtraction: OK
-DEAL:long double::Multiplication: OK
-DEAL:long double::Division: OK
-DEAL:long double::Multiplication scalar: OK
-DEAL:long double::Division scalar left: OK
-DEAL:long double::Division scalar right: OK
-DEAL:long double::Unary operator -: OK
-DEAL:long double::Unary operator +: OK
-DEAL:long double::Square root: OK
-DEAL:long double::Absolute value: OK
-DEAL:long double::Maximum value: OK
-DEAL:long double::Minimum value: OK
-DEAL:long double::Sine: OK
-DEAL:long double::Cosine: OK
-DEAL:long double::Tangent: OK
-DEAL:long double::Exponential: OK
-DEAL:long double::Logarithm: OK