mpir/tests/cxx/t-constr.cc

/* Test mp*_class constructors.

Copyright 2001, 2002, 2003 Free Software Foundation, Inc.

This file is part of the GNU MP Library.

The GNU MP Library is free software; you can 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 GNU MP Library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
License for more details.

You should have received a copy of the GNU Lesser General Public License
along with the GNU MP Library; see the file COPYING.LIB.  If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */

#include "config.h"

#include <iostream>
#include <string>

#include "mpir.h"
#include "mpirxx.h"
#include "gmp-impl.h"
#include "tests.h"

using namespace std;


void
check_mpz (void)
{
  // mpz_class()
  {
    mpz_class a; ASSERT_ALWAYS(a == 0);
  }

  // mpz_class(const mpz_class &)
  // see below

  // template <class T, class U> mpz_class(const __gmp_expr<T, U> &)
  // not tested here, see t-unary.cc, t-binary.cc

  // mpz_class(signed char)
  {
    signed char a = -127;
    mpz_class b(a); ASSERT_ALWAYS(b == -127);
  }

  // mpz_class(unsigned char)
  {
    unsigned char a = 255;
    mpz_class b(a); ASSERT_ALWAYS(b == 255);
  }

  // either signed or unsigned char, machine dependent
  {
    mpz_class a('A'); ASSERT_ALWAYS(a == 65);
  }
  {
    mpz_class a('z'); ASSERT_ALWAYS(a == 122);
  }

  // mpz_class(signed int)
  {
    signed int a = 0;
    mpz_class b(a); ASSERT_ALWAYS(b == 0);
  }
  {
    signed int a = -123;
    mpz_class b(a); ASSERT_ALWAYS(b == -123);
  }
  {
    signed int a = 4567;
    mpz_class b(a); ASSERT_ALWAYS(b == 4567);
  }

  // mpz_class(unsigned int)
  {
    unsigned int a = 890;
    mpz_class b(a); ASSERT_ALWAYS(b == 890);
  }

  // mpz_class(signed short int)
  {
    signed short int a = -12345;
    mpz_class b(a); ASSERT_ALWAYS(b == -12345);
  }

  // mpz_class(unsigned short int)
  {
    unsigned short int a = 54321u;
    mpz_class b(a); ASSERT_ALWAYS(b == 54321u);
  }

  // mpz_class(signed long int)
  {
    signed long int a = -1234567890L;
    mpz_class b(a); ASSERT_ALWAYS(b == -1234567890L);
  }

  // mpz_class(unsigned long int)
  {
    unsigned long int a = 1UL << 30;
    mpz_class b(a); ASSERT_ALWAYS(b == 1073741824L);
  }

  // mpz_class(float)
  {
    float a = 123.45;
    mpz_class b(a); ASSERT_ALWAYS(b == 123);
  }

  // mpz_class(double)
  {
    double a = 3.141592653589793238;
    mpz_class b(a); ASSERT_ALWAYS(b == 3);
  }

  // mpz_class(long double)
  // currently not implemented

  // mpz_class(const char *)
  {
    const char *a = "1234567890";
    mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  }

  // mpz_class(const char *, int)
  {
    const char *a = "FFFF";
    int base = 16;
    mpz_class b(a, base); ASSERT_ALWAYS(b == 65535u);
  }

  // mpz_class(const std::string &)
  {
    string a("1234567890");
    mpz_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  }

  // mpz_class(const std::string &, int)
  {
    string a("7777");
    int base = 8;
    mpz_class b(a, base); ASSERT_ALWAYS(b == 4095);
  }

  // mpz_class(const char *) with invalid
  {
    try {
      const char *a = "ABC";
      mpz_class b(a);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpz_class(const char *, int) with invalid
  {
    try {
      const char *a = "GHI";
      int base = 16;
      mpz_class b(a, base);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpz_class(const std::string &) with invalid
  {
    try {
      string a("abc");
      mpz_class b(a);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpz_class(const std::string &, int) with invalid
  {
    try {
      string a("ZZZ");
      int base = 8;
      mpz_class b(a, base);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpz_class(mpz_srcptr)
  {
    mpz_t a;
    mpz_init_set_ui(a, 100);
    mpz_class b(a); ASSERT_ALWAYS(b == 100);
    mpz_clear(a);
  }

  // mpz_class(const mpz_class &)
  {
    mpz_class a(12345); // tested above, assume it works
    mpz_class b(a); ASSERT_ALWAYS(b == 12345);
  }

  // no constructor for bool, but it gets casted to int
  {
    bool a = true;
    mpz_class b(a); ASSERT_ALWAYS(b == 1);
  }
  {
    bool a = false;
    mpz_class b(a); ASSERT_ALWAYS(b == 0);
  }
}

void
check_mpq (void)
{
  // mpq_class()
  {
    mpq_class a; ASSERT_ALWAYS(a == 0);
  }

  // mpq_class(const mpq_class &)
  // see below

  // template <class T, class U> mpq_class(const __gmp_expr<T, U> &)
  // not tested here, see t-unary.cc, t-binary.cc

  // mpq_class(signed char)
  {
    signed char a = -127;
    mpq_class b(a); ASSERT_ALWAYS(b == -127);
  }

  // mpq_class(unsigned char)
  {
    unsigned char a = 255;
    mpq_class b(a); ASSERT_ALWAYS(b == 255);
  }

  // either signed or unsigned char, machine dependent
  {
    mpq_class a('A'); ASSERT_ALWAYS(a == 65);
  }
  {
    mpq_class a('z'); ASSERT_ALWAYS(a == 122);
  }

  // mpq_class(signed int)
  {
    signed int a = 0;
    mpq_class b(a); ASSERT_ALWAYS(b == 0);
  }
  {
    signed int a = -123;
    mpq_class b(a); ASSERT_ALWAYS(b == -123);
  }
  {
    signed int a = 4567;
    mpq_class b(a); ASSERT_ALWAYS(b == 4567);
  }

  // mpq_class(unsigned int)
  {
    unsigned int a = 890;
    mpq_class b(a); ASSERT_ALWAYS(b == 890);
  }

  // mpq_class(signed short int)
  {
    signed short int a = -12345;
    mpq_class b(a); ASSERT_ALWAYS(b == -12345);
  }

  // mpq_class(unsigned short int)
  {
    unsigned short int a = 54321u;
    mpq_class b(a); ASSERT_ALWAYS(b == 54321u);
  }

  // mpq_class(signed long int)
  {
    signed long int a = -1234567890L;
    mpq_class b(a); ASSERT_ALWAYS(b == -1234567890L);
  }

  // mpq_class(unsigned long int)
  {
    unsigned long int a = 1UL << 30;
    mpq_class b(a); ASSERT_ALWAYS(b == 1073741824L);
  }

  // mpq_class(float)
  {
    float a = 0.625;
    mpq_class b(a); ASSERT_ALWAYS(b == 0.625);
  }

  // mpq_class(double)
  {
    double a = 1.25;
    mpq_class b(a); ASSERT_ALWAYS(b == 1.25);
  }

  // mpq_class(long double)
  // currently not implemented

  // mpq_class(const char *)
  {
    const char *a = "1234567890";
    mpq_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  }

  // mpq_class(const char *, int)
  {
    const char *a = "FFFF";
    int base = 16;
    mpq_class b(a, base); ASSERT_ALWAYS(b == 65535u);
  }

  // mpq_class(const std::string &)
  {
    string a("1234567890");
    mpq_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  }

  // mpq_class(const std::string &, int)
  {
    string a("7777");
    int base = 8;
    mpq_class b(a, base); ASSERT_ALWAYS(b == 4095);
  }

  // mpq_class(const char *) with invalid
  {
    try {
      const char *a = "abc";
      mpq_class b(a);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpq_class(const char *, int) with invalid
  {
    try {
      const char *a = "ZZZ";
      int base = 16;
      mpq_class b (a, base);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpq_class(const std::string &) with invalid
  {
    try {
      string a("abc");
      mpq_class b(a);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpq_class(const std::string &, int) with invalid
  {
    try {
      string a("ZZZ");
      int base = 8;
      mpq_class b (a, base);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpq_class(mpq_srcptr)
  {
    mpq_t a;
    mpq_init(a);
    mpq_set_ui(a, 100, 1);
    mpq_class b(a); ASSERT_ALWAYS(b == 100);
    mpq_clear(a);
  }

  // mpq_class(const mpz_class &, const mpz_class &)
  {
    mpz_class a(123), b(4); // tested above, assume it works
    mpq_class c(a, b); ASSERT_ALWAYS(c == 30.75);
  }
  {
    mpz_class a(-1), b(2);  // tested above, assume it works
    mpq_class c(a, b); ASSERT_ALWAYS(c == -0.5);
  }
  {
    mpz_class a(5), b(4); // tested above, assume it works
    mpq_class c(a, b); ASSERT_ALWAYS(c == 1.25);
  }

  // mpq_class(const mpz_class &)
  {
    mpq_class a(12345); // tested above, assume it works
    mpq_class b(a); ASSERT_ALWAYS(b == 12345);
  }

  // no constructor for bool, but it gets casted to int
  {
    bool a = true;
    mpq_class b(a); ASSERT_ALWAYS(b == 1);
  }
  {
    bool a = false;
    mpq_class b(a); ASSERT_ALWAYS(b == 0);
  }
}

void
check_mpf (void)
{
  // mpf_class()
  {
    mpf_class a; ASSERT_ALWAYS(a == 0);
  }

  // mpf_class(const mpf_class &)
  // mpf_class(const mpf_class &, unsigned long int)
  // see below

  // template <class T, class U> mpf_class(const __gmp_expr<T, U> &)
  // template <class T, class U> mpf_class(const __gmp_expr<T, U> &,
  //                                       unsigned long int)
  // not tested here, see t-unary.cc, t-binary.cc

  // mpf_class(signed char)
  {
    signed char a = -127;
    mpf_class b(a); ASSERT_ALWAYS(b == -127);
  }

  // mpf_class(signed char, unsigned long int)
  {
    signed char a = -1;
    int prec = 64;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == -1);
  }

  // mpf_class(unsigned char)
  {
    unsigned char a = 255;
    mpf_class b(a); ASSERT_ALWAYS(b == 255);
  }

  // mpf_class(unsigned char, unsigned long int)
  {
    unsigned char a = 128;
    int prec = 128;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 128);
  }

  // either signed or unsigned char, machine dependent
  {
    mpf_class a('A'); ASSERT_ALWAYS(a == 65);
  }
  {
    int prec = 256;
    mpf_class a('z', prec); ASSERT_ALWAYS(a == 122);
  }

  // mpf_class(signed int)
  {
    signed int a = 0;
    mpf_class b(a); ASSERT_ALWAYS(b == 0);
  }
  {
    signed int a = -123;
    mpf_class b(a); ASSERT_ALWAYS(b == -123);
  }
  {
    signed int a = 4567;
    mpf_class b(a); ASSERT_ALWAYS(b == 4567);
  }

  // mpf_class(signed int, unsigned long int)
  {
    signed int a = -123;
    int prec = 64;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == -123);
  }

  // mpf_class(unsigned int)
  {
    unsigned int a = 890;
    mpf_class b(a); ASSERT_ALWAYS(b == 890);
  }

  // mpf_class(unsigned int, unsigned long int)
  {
    unsigned int a = 890;
    int prec = 128;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 890);
  }

  // mpf_class(signed short int)
  {
    signed short int a = -12345;
    mpf_class b(a); ASSERT_ALWAYS(b == -12345);
  }

  // mpf_class(signed short int, unsigned long int)
  {
    signed short int a = 6789;
    int prec = 256;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 6789);
  }

  // mpf_class(unsigned short int)
  {
    unsigned short int a = 54321u;
    mpf_class b(a); ASSERT_ALWAYS(b == 54321u);
  }

  // mpf_class(unsigned short int, unsigned long int)
  {
    unsigned short int a = 54321u;
    int prec = 64;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 54321u);
  }

  // mpf_class(signed long int)
  {
    signed long int a = -1234567890L;
    mpf_class b(a); ASSERT_ALWAYS(b == -1234567890L);
  }

  // mpf_class(signed long int, unsigned long int)
  {
    signed long int a = -1234567890L;
    int prec = 128;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == -1234567890L);
  }

  // mpf_class(unsigned long int)
  {
    unsigned long int a = 3456789012UL;
    mpf_class b(a); ASSERT_ALWAYS(b == 3456789012UL);
  }

  // mpf_class(unsigned long int, unsigned long int)
  {
    unsigned long int a = 3456789012UL;
    int prec = 256;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 3456789012UL);
  }

  // mpf_class(float)
  {
    float a = 1234.5;
    mpf_class b(a); ASSERT_ALWAYS(b == 1234.5);
  }

  // mpf_class(float, unsigned long int)
  {
    float a = 1234.5;
    int prec = 64;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234.5);
  }

  // mpf_class(double)
  {
    double a = 12345.0;
    mpf_class b(a); ASSERT_ALWAYS(b == 12345);
  }
  {
    double a = 1.2345e+4;
    mpf_class b(a); ASSERT_ALWAYS(b == 12345);
  }
  {
    double a = 312.5e-2;
    mpf_class b(a); ASSERT_ALWAYS(b == 3.125);
  }

  // mpf_class(double, unsigned long int)
  {
    double a = 5.4321e+4;
    int prec = 128;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 54321L);
  }

  // mpf_class(long double)
  // mpf_class(long double, unsigned long int)
  // currently not implemented

  // mpf_class(const char *)
  {
    const char *a = "1234567890";
    mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  }

  // mpf_class(const char *, unsigned long int, int = 0)
  {
    const char *a = "1234567890";
    int prec = 256;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
  }
  {
    const char *a = "777777";
    int prec = 64, base = 8;
    mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 262143L);
  }

  // mpf_class(const std::string &)
  {
    string a("1234567890");
    mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
  }

  // mpf_class(const std::string &, unsigned long int, int = 0)
  {
    string a("1234567890");
    int prec = 128;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
  }
  {
    string a("FFFF");
    int prec = 256, base = 16;
    mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 65535u);
  }

  // mpf_class(const char *) with invalid
  {
    try {
      const char *a = "abc";
      mpf_class b(a);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpf_class(const char *, unsigned long int, int = 0) with invalid
  {
    try {
      const char *a = "def";
      int prec = 256;
      mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }
  {
    try {
      const char *a = "ghi";
      int prec = 64, base = 8;
      mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 262143L);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpf_class(const std::string &) with invalid
  {
    try {
      string a("abc");
      mpf_class b(a); ASSERT_ALWAYS(b == 1234567890L);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpf_class(const std::string &, unsigned long int, int = 0) with invalid
  {
    try {
      string a("def");
      int prec = 128;
      mpf_class b(a, prec); ASSERT_ALWAYS(b == 1234567890L);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }
  {
    try {
      string a("ghi");
      int prec = 256, base = 16;
      mpf_class b(a, prec, base); ASSERT_ALWAYS(b == 65535u);
      ASSERT_ALWAYS (0);  /* should not be reached */
    } catch (invalid_argument) {
    }
  }

  // mpf_class(mpf_srcptr)
  {
    mpf_t a;
    mpf_init_set_ui(a, 100);
    mpf_class b(a); ASSERT_ALWAYS(b == 100);
    mpf_clear(a);
  }

  // mpf_class(mpf_srcptr, unsigned long int)
  {
    mpf_t a;
    int prec = 64;
    mpf_init_set_ui(a, 100);
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 100);
    mpf_clear(a);
  }

  // mpf_class(const mpf_class &)
  {
    mpf_class a(12345); // tested above, assume it works
    mpf_class b(a); ASSERT_ALWAYS(b == 12345);
  }

  // mpf_class(const mpf_class &, unsigned long int)
  {
    mpf_class a(12345); // tested above, assume it works
    int prec = 64;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 12345);
  }

  // no constructors for bool, but it gets casted to int
  {
    bool a = true;
    mpf_class b(a); ASSERT_ALWAYS(b == 1);
  }
  {
    bool a = false;
    mpf_class b(a); ASSERT_ALWAYS(b == 0);
  }
  {
    bool a = true;
    int prec = 128;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 1);
  }
  {
    bool a = false;
    int prec = 256;
    mpf_class b(a, prec); ASSERT_ALWAYS(b == 0);
  }
}



int
main (void)
{
  tests_start();

  check_mpz();
  check_mpq();
  check_mpf();

  tests_end();
  return 0;
}