coeffs_test.h File Reference

#include "misc/auxiliary.h"
#include "reporter/reporter.h"
#include "resources/feResource.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "coeffs/longrat.h"
#include "coeffs/gnumpfl.h"
#include "coeffs/gnumpc.h"
#include "coeffs/shortfl.h"
#include "coeffs/ffields.h"
#include "coeffs/modulop.h"
#include "coeffs/rmodulon.h"
#include "coeffs/rmodulo2m.h"
#include "coeffs/rintegers.h"
#include "common.h"

Go to the source code of this file.

Data Structures
class	CoeffsTestSuite

Functions
void	TestSum (const coeffs r, const unsigned long N)
void	TestArith (const coeffs r)
BOOLEAN	Test (const n_coeffType type, void *p=NULLp)

Variables
static GlobalPrintingFixture	globalPrintingFixture

Function Documentation

Test()

BOOLEAN Test	(	const n_coeffType	type,
		void *	p = NULLp
	)

Definition at line 209 of file coeffs_test.h.

{
 
  clog << endl;
  clog << ( "----------------------- Testing coeffs: [" + _2S(type) +  ", " + _2S(p) + "]: -----------------------");
  clog << endl;
 
  const coeffs r = nInitChar( type, p );
 
  if( r == NULLp )
  {
    clog << ( "Test: could not get this coeff. domain" );
    return FALSE;
  };
 
  TS_ASSERT_DIFFERS( r->cfCoeffWrite, NULLp );
 
  if( r->cfCoeffWrite != NULL )
  {
    clog << "Coeff-domain: "  << endl;
    n_CoeffWrite(r); PrintLn();
  }
 
  if (n_NumberOfParameters(r) > 0)
  {
    number z = n_Param(1, r); // also any integer instead of 0//?
    PrintS("Parameter: "); PrintSized(z, r);
    n_Delete(&z, r);
  }
 
 
  clog << "Char: " << n_GetChar(r) << endl;
 
 
  TS_ASSERT_DIFFERS( r, NULLp );
  nSetChar( r );
  TS_ASSERT_EQUALS( getCoeffType(r), type );
 
  TS_ASSERT_DIFFERS( r->cfInit, NULLp );
  TS_ASSERT_DIFFERS( r->cfWriteLong, NULLp );
  TS_ASSERT_DIFFERS( r->cfAdd, NULLp );
  TS_ASSERT_DIFFERS( r->cfDelete, NULLp );
 
  switch( type )
  {
    case n_Q:
    {
      //TS_ASSERT_EQUALS( r->cfInit, nlInit );
      //TS_ASSERT_EQUALS( r->cfAdd, nlAdd );
      //TS_ASSERT_EQUALS( r->cfDelete, nlDelete );
 
      TS_ASSERT(  nCoeff_is_Q( r ));
      TS_ASSERT(  nCoeff_is_Domain( r ));
 
      TS_ASSERT( !nCoeff_has_Units( r )); // ?
      TS_ASSERT( !nCoeff_has_simple_inverse( r ));// ?
      TS_ASSERT( !nCoeff_has_simple_Alloc( r )); // ?
 
      TS_ASSERT( !nCoeff_is_Ring_2toM( r ));
      TS_ASSERT( !nCoeff_is_Zn( r ));
      TS_ASSERT( !nCoeff_is_Ring_PtoM( r ));
      TS_ASSERT( !nCoeff_is_Z( r ));
      TS_ASSERT( !nCoeff_is_Ring( r ));
      TS_ASSERT( !nCoeff_is_Zp( r ));
      TS_ASSERT( !nCoeff_is_numeric( r ));
      TS_ASSERT( !nCoeff_is_R( r ));
      TS_ASSERT( !nCoeff_is_GF( r ));
      TS_ASSERT( !nCoeff_is_long_R( r ));
      TS_ASSERT( !nCoeff_is_long_C( r ));
      TS_ASSERT( !nCoeff_is_CF( r ));
      TS_ASSERT( !nCoeff_is_Extension( r ));
 
      break;
    }
    case n_long_R:
    {
      //TS_ASSERT_EQUALS( r->cfInit, ngfInit );
      //TS_ASSERT_EQUALS( r->cfAdd, ngfAdd );
      //TS_ASSERT_EQUALS( r->cfDelete, ngfDelete );
      break;
    }
    case n_long_C:
    {
//       TS_ASSERT_EQUALS( r->cfInit, ngcInit );
//       TS_ASSERT_EQUALS( r->cfAdd, ngcAdd );
//       TS_ASSERT_EQUALS( r->cfDelete, ngcDelete );
      break;
    }
    case n_R:
    {
      //TS_ASSERT_EQUALS( r->cfInit, nrInit );
      //TS_ASSERT_EQUALS( r->cfAdd, nrAdd );
  //    TS_ASSERT_EQUALS( r->cfDelete, nrDelete ); // No?
      break;
    }
    case n_GF:
    {
//       TS_ASSERT_EQUALS( r->cfInit, nfInit );
//       TS_ASSERT_EQUALS( r->cfAdd, nfAdd );
      //TS_ASSERT_EQUALS( r->cfDelete, nfDelete );
      break;
    }
#ifdef HAVE_RINGS
    case n_Z2m:
    {
      //TS_ASSERT_EQUALS( r->cfInit, nr2mInit );
      //TS_ASSERT_EQUALS( r->cfAdd, nr2mAdd );
      //TS_ASSERT_EQUALS( r->cfDelete, ndDelete );
      break;
    }
    case n_Zn:
    {
      //TS_ASSERT_EQUALS( r->cfInit, nrnInit );
      //TS_ASSERT_EQUALS( r->cfAdd, nrnAdd );
      //TS_ASSERT_EQUALS( r->cfDelete, nrnDelete );
      break;
    }
#endif
    default:
    {
      // ...
    }
  }
 
  TestArith( r );
  TestSum( r, 10 );
  TestSum( r, 100 );
  TestSum( r, 101 );
  TestSum( r, 1001 );
  TestSum( r, 9000 );
 
  nKillChar( r );
 
  return TRUE;
}

TestArith()

void TestArith

(

const coeffs

r

)

Definition at line 109 of file coeffs_test.h.

{
  clog << ("TEST: Simple Arithmetics: ");
  clog << endl;
 
  number two = n_Init(2, r);
 
  number t = n_Init(1, r);
  n_InpAdd(t, t, r);
  TS_ASSERT( n_Equal(two, t, r) );
  n_Delete(&t, r);
 
  if( getCoeffType(r) == n_Q )
  {
    number t = n_Init(1, r);
    n_InpAdd(t, t, r);
    TS_ASSERT( n_Equal(two, t, r) );
    n_Delete(&t, r);
  }
 
 
 
 
  const int N = 66666;
 
  number a = n_Init(N, r);
 
  clog<< "a: "; PrintSized(a, r);
 
 
  clog<< "two: "; PrintSized(two, r);
 
  number aa0 = n_Init(N*2, r);
 
  number aa = n_Add(a, a, r);
 
  clog<< "aa = a + a: "; PrintSized(aa, r);
 
  number aa2 = n_Mult(a, two, r);
 
  clog<< "aa2 = a * 2: "; PrintSized(aa2, r);
 
  number aa1 = n_Mult(two, a, r);
 
  clog<< "aa1 = 2 * a: "; PrintSized(aa1, r);
 
  n_Delete(&a, r);
  n_Delete(&two, r);
 
 
  a = n_Sub( aa, aa1, r );
 
  clog<< "a = aa - aa1: "; PrintSized(a, r);
 
  TS_ASSERT( n_IsZero(a, r) );
 
  n_Delete(&a, r);
 
  a = n_Sub( aa, aa2, r );
 
  clog<< "a = aa - aa2: "; PrintSized(a, r);
 
  TS_ASSERT( n_IsZero(a, r) );
 
  n_Delete(&a, r);
 
 
  a = n_Sub( aa1, aa2, r );
 
  clog<< "a = aa1 - aa2: "; PrintSized(a, r);
 
  TS_ASSERT( n_IsZero(a, r) );
 
  n_Delete(&a, r);
 
 
 
  TS_ASSERT( n_Equal(aa, aa1, r) );
  TS_ASSERT( n_Equal(aa, aa2, r) );
  TS_ASSERT( n_Equal(aa1, aa2, r) );
 
  TS_ASSERT( n_Equal(aa0, aa, r) );
  TS_ASSERT( n_Equal(aa0, aa1, r) );
  TS_ASSERT( n_Equal(aa0, aa2, r) );
 
  n_Delete(&aa, r);
  n_Delete(&aa1, r);
  n_Delete(&aa2, r);
 
  n_Delete(&aa0, r);
 
  clog << ( " >>> TEST DONE!" );
  clog << endl;
 
}

TestSum()

void TestSum	(	const coeffs	r,
		const unsigned long	N
	)

Definition at line 25 of file coeffs_test.h.

{
  clog << ( _2S("TEST: sum[0..") + _2S(N) + "]: ");
  clog << endl;
 
  assume( N > 0 ); // just for now...
 
  const unsigned long ssss = (N * (N+1)) / 2;
 
  number sum1 = n_Init(ssss, r);
  clog<< "N*(N+1)/2 (int: " << ssss << "): "; PrintSized(sum1, r);
 
  number s, ss, i, res;
 
  s = n_Init(N  , r);
  i = n_Init(N+1, r);
  n_InpMult(s, i, r);
  n_Delete(&i, r);
 
  clog<< "N*(N+1): ("<< N*(N+1) << ")"; PrintSized(s, r);
 
  i = n_Init(2, r);
  clog<< "2: "; PrintSized(i, r);
 
  if( !n_IsZero( i, r) )
  {
#ifdef HAVE_RINGS
    TS_ASSERT( n_DivBy(s, i, r) );
#endif
 
    res = n_Div(s, i, r);
 
    clog<< "N*(N+1)/2: "; PrintSized(res, r);
 
 
    number d = n_Sub(res, sum1, r);
    TS_ASSERT( n_IsZeroDivisor(d, r) );
    n_Delete(&d, r);
 
    if( n_GetChar(r) == 0 )
    {
      TS_ASSERT( n_Equal(sum1, res, r) );
      TS_ASSERT( n_Equal(res, sum1, r) );
    }
  } else
    TS_ASSERT_EQUALS( n_GetChar(r), 2);
 
 
  n_Delete(&s, r);  n_Delete(&i, r);
 
  n_Delete(&sum1, r); n_Delete(&res, r);
 
 
  s = n_Init(0  , r);
  ss = n_Init(0 , r);
  for( int k = N; k >= 0; k-- )
  {
    i = n_Init(k, r);
    n_InpAdd(s, i, r); // s += i
 
    i = n_InpNeg(i, r);
    n_InpAdd(ss, i, r); // ss -= i
 
    n_Delete(&i, r);
  }
  clog<< "ss: "; PrintSized(ss, r);
 
  ss = n_InpNeg(ss, r); // ss = -ss
 
  clog<< "real sum    : "; PrintSized(s, r);
  clog<< "real sum(--): "; PrintSized(ss, r);
 
  TS_ASSERT( n_Equal(s, ss, r) );
  TS_ASSERT( n_Equal(ss, s, r) );
 
  n_Delete(&s, r);
  n_Delete(&ss, r);
 
  clog << ( " >>> TEST DONE!" );
  clog << endl;
 
}

Variable Documentation

globalPrintingFixture

GlobalPrintingFixture globalPrintingFixture

static

Definition at line 350 of file coeffs_test.h.