Quelle initializer_list_construction.cpp Sprache: C

// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2019 David Tellenbach <david.tellenbach@tellnotes.org>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#define EIGEN_NO_STATIC_ASSERT

#include "main.h"

template<typename Scalar, bool is_integer = NumTraits<Scalar>::IsInteger>
struct TestMethodDispatching {
  static void run() {}
};

template<typename Scalar>
struct TestMethodDispatching<Scalar, 1> {
  static void run()
  {
    {
      Matrix<Scalar, Dynamic, Dynamic> m {3, 4};
      Array<Scalar, Dynamic, Dynamic> a {3, 4};
      VERIFY(m.rows() == 3);
      VERIFY(m.cols() == 4);
      VERIFY(a.rows() == 3);
      VERIFY(a.cols() == 4);
    }
    {
      Matrix<Scalar, 1, 2> m {3, 4};
      Array<Scalar, 1, 2> a {3, 4};
      VERIFY(m(0) == 3);
      VERIFY(m(1) == 4);
      VERIFY(a(0) == 3);
      VERIFY(a(1) == 4);
    }
    {
      Matrix<Scalar, 2, 1> m {3, 4};
      Array<Scalar, 2, 1> a {3, 4};
      VERIFY(m(0) == 3);
      VERIFY(m(1) == 4);
      VERIFY(a(0) == 3);
      VERIFY(a(1) == 4);
    }
  }
};

template<typename Vec4, typename Vec5> void fixedsizeVariadicVectorConstruction2()
{
  {
    Vec4 ref = Vec4::Random();
    Vec4 v{ ref[0], ref[1], ref[2], ref[3] };
    VERIFY_IS_APPROX(v, ref);
    VERIFY_IS_APPROX(v, (Vec4( ref[0], ref[1], ref[2], ref[3] )));
    VERIFY_IS_APPROX(v, (Vec4({ref[0], ref[1], ref[2], ref[3]})));

    Vec4 v2 = { ref[0], ref[1], ref[2], ref[3] };
    VERIFY_IS_APPROX(v2, ref);
  }
  {
    Vec5 ref = Vec5::Random();
    Vec5 v{ ref[0], ref[1], ref[2], ref[3], ref[4] };
    VERIFY_IS_APPROX(v, ref);
    VERIFY_IS_APPROX(v, (Vec5( ref[0], ref[1], ref[2], ref[3], ref[4] )));
    VERIFY_IS_APPROX(v, (Vec5({ref[0], ref[1], ref[2], ref[3], ref[4]})));

    Vec5 v2 = { ref[0], ref[1], ref[2], ref[3], ref[4] };
    VERIFY_IS_APPROX(v2, ref);
  }
}

#define CHECK_MIXSCALAR_V5_APPROX(V, A0, A1, A2, A3, A4) { \
  VERIFY_IS_APPROX(V[0], Scalar(A0) ); \
  VERIFY_IS_APPROX(V[1], Scalar(A1) ); \
  VERIFY_IS_APPROX(V[2], Scalar(A2) ); \
  VERIFY_IS_APPROX(V[3], Scalar(A3) ); \
  VERIFY_IS_APPROX(V[4], Scalar(A4) ); \
}

#define CHECK_MIXSCALAR_V5(VEC5, A0, A1, A2, A3, A4) { \
  typedef VEC5::Scalar Scalar; \
  VEC5 v = { A0 , A1 , A2 , A3 , A4 }; \
  CHECK_MIXSCALAR_V5_APPROX(v, A0 , A1 , A2 , A3 , A4); \
}

template<int> void fixedsizeVariadicVectorConstruction3()
{
  typedef Matrix<double,5,1> Vec5;
  typedef Array<float,5,1> Arr5;
  CHECK_MIXSCALAR_V5(Vec5, 1, 2., -3, 4.121, 5.53252);
  CHECK_MIXSCALAR_V5(Arr5, 1, 2., 3.12f, 4.121, 5.53252);
}

template<typename Scalar> void fixedsizeVariadicVectorConstruction()
{
  CALL_SUBTEST(( fixedsizeVariadicVectorConstruction2<Matrix<Scalar,4,1>, Matrix<Scalar,5,1> >() ));
  CALL_SUBTEST(( fixedsizeVariadicVectorConstruction2<Matrix<Scalar,1,4>, Matrix<Scalar,1,5> >() ));
  CALL_SUBTEST(( fixedsizeVariadicVectorConstruction2<Array<Scalar,4,1>,  Array<Scalar,5,1>  >() ));
  CALL_SUBTEST(( fixedsizeVariadicVectorConstruction2<Array<Scalar,1,4>,  Array<Scalar,1,5>  >() ));
}

template<typename Scalar> void initializerListVectorConstruction()
{
  Scalar raw[4];
  for(int k = 0; k < 4; ++k) {
    raw[k] = internal::random<Scalar>();
  }
  {
    Matrix<Scalar, 4, 1> m { {raw[0]}, {raw[1]},{raw[2]},{raw[3]} };
    Array<Scalar, 4, 1> a { {raw[0]}, {raw[1]}, {raw[2]}, {raw[3]} };
    for(int k = 0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for(int k = 0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar,4,1>({ {raw[0]}, {raw[1]}, {raw[2]}, {raw[3]} })));
    VERIFY((a == (Array<Scalar,4,1>({ {raw[0]}, {raw[1]}, {raw[2]}, {raw[3]} }))).all());
  }
  {
    Matrix<Scalar, 1, 4> m { {raw[0], raw[1], raw[2], raw[3]} };
    Array<Scalar, 1, 4> a { {raw[0], raw[1], raw[2], raw[3]} };
    for(int k = 0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for(int k = 0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 1, 4>({{raw[0],raw[1],raw[2],raw[3]}})));
    VERIFY((a == (Array<Scalar, 1, 4>({{raw[0],raw[1],raw[2],raw[3]}}))).all());
  }
  {
    Matrix<Scalar, 4, Dynamic> m { {raw[0]}, {raw[1]}, {raw[2]}, {raw[3]} };
    Array<Scalar, 4, Dynamic> a { {raw[0]}, {raw[1]}, {raw[2]}, {raw[3]} };
    for(int k=0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for(int k=0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, 4, Dynamic>({ {raw[0]}, {raw[1]}, {raw[2]}, {raw[3]} })));
    VERIFY((a == (Array<Scalar, 4, Dynamic>({ {raw[0]}, {raw[1]}, {raw[2]}, {raw[3]} }))).all());
  }
  {
    Matrix<Scalar, Dynamic, 4> m {{raw[0],raw[1],raw[2],raw[3]}};
    Array<Scalar, Dynamic, 4> a {{raw[0],raw[1],raw[2],raw[3]}};
    for(int k=0; k < 4; ++k) {
      VERIFY(m(k) == raw[k]);
    }
    for(int k=0; k < 4; ++k) {
      VERIFY(a(k) == raw[k]);
    }
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, Dynamic, 4>({{raw[0],raw[1],raw[2],raw[3]}})));
    VERIFY((a == (Array<Scalar, Dynamic, 4>({{raw[0],raw[1],raw[2],raw[3]}}))).all());
  }
}

template<typename Scalar> void initializerListMatrixConstruction()
{
  const Index RowsAtCompileTime = 5;
  const Index ColsAtCompileTime = 4;
  const Index SizeAtCompileTime = RowsAtCompileTime * ColsAtCompileTime;

  Scalar raw[SizeAtCompileTime];
  for (int i = 0; i < SizeAtCompileTime; ++i) {
    raw[i] = internal::random<Scalar>();
  }
  {
    Matrix<Scalar, Dynamic, Dynamic> m {};
    VERIFY(m.cols() == 0);
    VERIFY(m.rows() == 0);
    VERIFY_IS_EQUAL(m, (Matrix<Scalar, Dynamic, Dynamic>()));
  }
  {
    Matrix<Scalar, 5, 4> m {
      {raw[0], raw[1], raw[2], raw[3]},
      {raw[4], raw[5], raw[6], raw[7]},
      {raw[8], raw[9], raw[10], raw[11]},
      {raw[12], raw[13], raw[14], raw[15]},
      {raw[16], raw[17], raw[18], raw[19]}
    };

    Matrix<Scalar, 5, 4> m2;
    m2 << raw[0], raw[1], raw[2], raw[3],
          raw[4], raw[5], raw[6], raw[7],
          raw[8], raw[9], raw[10], raw[11],
          raw[12], raw[13], raw[14], raw[15],
          raw[16], raw[17], raw[18], raw[19];

    int k = 0;
    for(int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }
    VERIFY_IS_EQUAL(m, m2);
  }
  {
    Matrix<Scalar, Dynamic, Dynamic> m{
      {raw[0], raw[1], raw[2], raw[3]},
      {raw[4], raw[5], raw[6], raw[7]},
      {raw[8], raw[9], raw[10], raw[11]},
      {raw[12], raw[13], raw[14], raw[15]},
      {raw[16], raw[17], raw[18], raw[19]}
    };

    VERIFY(m.cols() == 4);
    VERIFY(m.rows() == 5);
    int k = 0;
    for(int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }

    Matrix<Scalar, Dynamic, Dynamic> m2(RowsAtCompileTime, ColsAtCompileTime);
    k = 0;
    for(int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        m2(i, j) = raw[k];
        ++k;
      }
    }
    VERIFY_IS_EQUAL(m, m2);
  }
}

template<typename Scalar> void initializerListArrayConstruction()
{
  const Index RowsAtCompileTime = 5;
  const Index ColsAtCompileTime = 4;
  const Index SizeAtCompileTime = RowsAtCompileTime * ColsAtCompileTime;

  Scalar raw[SizeAtCompileTime];
  for (int i = 0; i < SizeAtCompileTime; ++i) {
    raw[i] = internal::random<Scalar>();
  }
  {
    Array<Scalar, Dynamic, Dynamic> a {};
    VERIFY(a.cols() == 0);
    VERIFY(a.rows() == 0);
  }
  {
    Array<Scalar, 5, 4> m {
      {raw[0], raw[1], raw[2], raw[3]},
      {raw[4], raw[5], raw[6], raw[7]},
      {raw[8], raw[9], raw[10], raw[11]},
      {raw[12], raw[13], raw[14], raw[15]},
      {raw[16], raw[17], raw[18], raw[19]}
    };

    Array<Scalar, 5, 4> m2;
    m2 << raw[0], raw[1], raw[2], raw[3],
          raw[4], raw[5], raw[6], raw[7],
          raw[8], raw[9], raw[10], raw[11],
          raw[12], raw[13], raw[14], raw[15],
          raw[16], raw[17], raw[18], raw[19];

    int k = 0;
    for(int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }
    VERIFY_IS_APPROX(m, m2);
  }
  {
    Array<Scalar, Dynamic, Dynamic> m {
      {raw[0], raw[1], raw[2], raw[3]},
      {raw[4], raw[5], raw[6], raw[7]},
      {raw[8], raw[9], raw[10], raw[11]},
      {raw[12], raw[13], raw[14], raw[15]},
      {raw[16], raw[17], raw[18], raw[19]}
    };

    VERIFY(m.cols() == 4);
    VERIFY(m.rows() == 5);
    int k = 0;
    for(int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        VERIFY(m(i, j) == raw[k]);
        ++k;
      }
    }

    Array<Scalar, Dynamic, Dynamic> m2(RowsAtCompileTime, ColsAtCompileTime);
    k = 0;
    for(int i = 0; i < RowsAtCompileTime; ++i) {
      for (int j = 0; j < ColsAtCompileTime; ++j) {
        m2(i, j) = raw[k];
        ++k;
      }
    }
    VERIFY_IS_APPROX(m, m2);
  }
}

template<typename Scalar> void dynamicVectorConstruction()
{
  const Index size = 4;
  Scalar raw[size];
  for (int i = 0; i < size; ++i) {
    raw[i] = internal::random<Scalar>();
  }

  typedef Matrix<Scalar, Dynamic, 1>  VectorX;

  {
    VectorX v {{raw[0], raw[1], raw[2], raw[3]}};
    for (int i = 0; i < size; ++i) {
      VERIFY(v(i) == raw[i]);
    }
    VERIFY(v.rows() == size);
    VERIFY(v.cols() == 1);
    VERIFY_IS_EQUAL(v, (VectorX {{raw[0], raw[1], raw[2], raw[3]}}));
  }

  {
    VERIFY_RAISES_ASSERT((VectorX {raw[0], raw[1], raw[2], raw[3]}));
  }
  {
    VERIFY_RAISES_ASSERT((VectorX  {
      {raw[0], raw[1], raw[2], raw[3]},
      {raw[0], raw[1], raw[2], raw[3]},
    }));
  }
}

EIGEN_DECLARE_TEST(initializer_list_construction)
{
  CALL_SUBTEST_1(initializerListVectorConstruction<unsigned char>());
  CALL_SUBTEST_1(initializerListVectorConstruction<float>());
  CALL_SUBTEST_1(initializerListVectorConstruction<double>());
  CALL_SUBTEST_1(initializerListVectorConstruction<int>());
  CALL_SUBTEST_1(initializerListVectorConstruction<long int>());
  CALL_SUBTEST_1(initializerListVectorConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_1(initializerListVectorConstruction<std::complex<double>>());
  CALL_SUBTEST_1(initializerListVectorConstruction<std::complex<float>>());

  CALL_SUBTEST_2(initializerListMatrixConstruction<unsigned char>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<float>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<double>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<int>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<long int>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<std::complex<double>>());
  CALL_SUBTEST_2(initializerListMatrixConstruction<std::complex<float>>());

  CALL_SUBTEST_3(initializerListArrayConstruction<unsigned char>());
  CALL_SUBTEST_3(initializerListArrayConstruction<float>());
  CALL_SUBTEST_3(initializerListArrayConstruction<double>());
  CALL_SUBTEST_3(initializerListArrayConstruction<int>());
  CALL_SUBTEST_3(initializerListArrayConstruction<long int>());
  CALL_SUBTEST_3(initializerListArrayConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_3(initializerListArrayConstruction<std::complex<double>>());
  CALL_SUBTEST_3(initializerListArrayConstruction<std::complex<float>>());

  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<unsigned char>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<float>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<double>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<int>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<long int>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<std::complex<double>>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction<std::complex<float>>());
  CALL_SUBTEST_4(fixedsizeVariadicVectorConstruction3<0>());

  CALL_SUBTEST_5(TestMethodDispatching<int>::run());
  CALL_SUBTEST_5(TestMethodDispatching<long int>::run());

  CALL_SUBTEST_6(dynamicVectorConstruction<unsigned char>());
  CALL_SUBTEST_6(dynamicVectorConstruction<float>());
  CALL_SUBTEST_6(dynamicVectorConstruction<double>());
  CALL_SUBTEST_6(dynamicVectorConstruction<int>());
  CALL_SUBTEST_6(dynamicVectorConstruction<long int>());
  CALL_SUBTEST_6(dynamicVectorConstruction<std::ptrdiff_t>());
  CALL_SUBTEST_6(dynamicVectorConstruction<std::complex<double>>());
  CALL_SUBTEST_6(dynamicVectorConstruction<std::complex<float>>());
}

quality67%

¤ Dauer der Verarbeitung: 0.2 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.