------------------------------------------------------------------------------
--  File:            Test_int.adb
--  Description:     Test for Multi_precision_integers;
--  Author:          Gautier.deMontmollin@Maths.UniNe.CH
------------------------------------------------------------------------------

With Text_IO;                           Use  Text_IO;
With Multi_precision_integers;          Use  Multi_precision_integers;
With Multi_precision_integers_IO;       Use  Multi_precision_integers_IO;

procedure Test_Int is

  i,j,k,l: multi_int(20);

  shift: multi_int(1):= Multi( cardblock );

  -- Tests de puissance <<manuels>>
  m,n,o,p: multi_int(1200);

  s  : string(1..100);
  ls : natural;

  procedure Test_aff(s:string; i:multi_int;
                     detail: boolean:= false) is
    begin
      Put_Line("* Test [" & s & "]");
      if detail then
        Put("  [aff. blocs]  "); Put_in_blocks(i); New_Line;
        Put("  [aff. decimal]  Chiffres: "); Put(natural'image(chiffres(i)));
        Put("  D>" & Str(i) & "<D");
      else
        Put(i);
      end if;
      New_Line;
    end;

  procedure miniput( a: multi_int ) is
    begin
      if chiffres(a) <= 60 then
        put_in_blocks(a);
        put(a);
      else
        put("(big...)");
      end if;
    end;

  function Test_egalite( a,b: multi_int;
                          nom: String ) return boolean is
    begin
      if not Equal( a , b ) then
        new_line;
        put("Erreur [" & nom & ";a="); miniput(a);
        put(";b=");   miniput(b);
        put(";a-b="); miniput(a - b);
        put("] [ret]");
        skip_line;
        return false;
      else
        return true;
      end if;
    end;

  procedure Pause is
    begin
      Put("[ Pressez Return SVP ]"); Skip_Line;
    end Pause;

  function Decimales_Pi(N: Natural) return multi_int is
    X,Y,S: multi_int(index_int(N));

    procedure Arctg(m,c,e: Integer) is
      i: Positive:= 1;
      moins: Boolean;
      begin
        Fill(X, (c*(Multi(10)**N)) / m);
        Fill(S, S + e*X);
        while not X.zero loop
          Fill(X, X / (m*m));
          Fill(Y, X / (2*i + 1));
          if i mod 2 =1 then
            moins:=     (e=1);
          else
            moins:= NOT (e=1);
          end if;
          if moins then
             Sub(S,Y, S);
           else
             Add(S,Y, S);
          end if;
          i:= i + 1;
        end loop;
      end Arctg;

    begin
      Arctg(18, 48, 1); -- formule de Gauss
      Arctg(57, 32, 1);
      Arctg(239,20,-1);
      return S;
    end Decimales_Pi;

  -- Nombres de Syracuse. Idee transmise par Eric Batard.

  procedure Syracuse(i0: multi_int) is
    fin: constant multi_int:= Multi(1);
    i:   multi_int(20);
    begin
      Fill(i, i0);
      loop
        if Even(i) then
          Fill(i, i/2);
        else
          Fill(i, (3*i+1)/2);
        end if;
        Put(i);
        New_line;
        exit when Equal(i,fin);
      end loop;
    end Syracuse;

  begin

    Test_aff( "1234567890...",
              Val("1234567890123456789012345678901234567890"), true);

    Test_aff( "Billions...", Val("1000000") *  Val("1000000") );

    Test_aff( "Mersenne a)  (2^1931-1) MOD 193949641 [=0 car 193949641" &
              " |(2^1931-1) ]",
                (Multi(2)**1931 -1) Mod Val("193949641") );

    Test_aff( "Mersenne b)  193949641=3863*50207",
                Val("193949641") / 3863 );


    Pause;

    Fill(m,     Val("1234567890"));
    Fill(m, m * Val("100000000010000000001"));

    for i in 0..36 loop
      Put(Multi(i), 3);      Put("     ");
      -- Put(Multi(10)**i, 25); Put("     ");
      Put( m  /  (Multi(10)**i) ); Put(" , ");
      Put( m MOD (Multi(10)**i) ); New_Line;
    end loop;

    loop
      begin
        Put("# Decimales de pi:");
        Get_line(s,ls);
        Test_aff( "Pi par formule de Gauss",
                   Decimales_pi(integer'value(s(1..ls))) );
        exit;
      exception
        when Constraint_error=> Put_Line("Nombre entier svp!");
      end;
    end loop;
    Pause;

    Test_aff( " 1 m/m", Multi(  10000 )  / Multi(  10000 ));
    Test_aff( " 0 m/m", Multi(  10000 )  / Multi(  10001 ));
    Test_aff( "-1 m/m", Multi( -10000 )  / Multi(  10000 ));
    Test_aff( " 0 m/m", Multi(  10000 )  / Multi( -10001 ));

    Test_aff( " 1 m/s", Multi(  10000 )  /   10000  );
    Test_aff( " 0 m/s", Multi(  10000 )  /   10001  );
    Test_aff( "-1 m/s", Multi( -10000 )  /   10000  );
    Test_aff( " 0 m/s", Multi(  10000 )  / (-10001 ));

    Test_aff( "-1230111", 100*Multi( -123 )*100 - 111 );

    Test_aff( "-23", Multi(  100 )  -         123  );
    Test_aff( "-23",         100    + Multi( -123 ));
    Test_aff( "+23",        -100    + Multi(  123 ));
    Test_aff( "+23", Multi( -100 )  -      ( -123 ));

    Pause;

    Fill( j, ((Multi( 56 ) * 100) * 10  + 88) );

    Test_aff( "j= 56088 = 123 * 456", j );
    Test_aff( "   5608  = j/10     ", j / 10 );
    Test_aff( "   560   = j/100    ", j / 100 );
    Test_aff( "j/1", j / 1 );     -- 56088 = 32768 + 23320
    Test_aff( "0=0/j", (0*j)/1);



    Test_aff( "",  j  /   123  );  --   456
    Test_aff( "",  j  / (-123) );  --   456
    Test_aff( "",(-j) /   123  );
    Test_aff( "",(-j) / (-123) );

    Fill( i, Multi(100)*Multi(100)*10 + Multi(100) ); --   100100

    Test_aff( "i=100100",i );
    Test_aff( "  10010 ",i / 10 );    --   10010
    Test_aff( "  1001  ",i / 100 );   --   1001

    Fill( k, Multi(123) );
    Fill( l, Multi(456) );

    Test_aff( " j^5",             j*j*j*j*j );
    Test_aff( " j^5/k^5",        (j*j*j*j*j) /     (k*k*k*k*k) );
    Test_aff( "-j^5/k^5/l^4", (-(-j*j*j*j*j) /  (-(-k*k*k*k*k))) /
                                (-l*l*l*l) );

    Test_aff( "2^31 (32-bits)", Multi( Integer'Last ) );
    Test_aff( "2^16 (32-bits)", Multi( 32768 ) );

    Test_aff( "-{:|:|:| 100| 0}",
                100 * shift
              - 200 * shift, true );

    Test_aff( "-{:|:|:| 666| 0| 0}",
                322 * (shift*shift)
              - 988 * (shift*shift), true );

    Test_aff( "0=.....", ((j-l*l)*2)-j*2+2*l**2);

    Test_aff( "shift(20)", shift ** 20, true );
    Test_aff( "1 - shift(6)", 1 - shift ** 6, true );
      -- -{:|:|:|:| 32767| 32767| 32767| 32767| 32767| 32767}

    Pause;

    -- Maintenant, les gros moyens...

    Put_Line("test * et **");

    for puiss in 1..250 loop

      Fill( m, j );
      Fill( n, k );
      Fill( o, l );
      for i in 2 .. puiss loop
         Fill(m, m*j );
         Fill(n, n*k );
         Fill(o, o*l );
      end loop;

      put(integer'image(puiss));
      if not Equal( m, j**puiss ) then put("err m"); end if;
      if not Equal( n, k**puiss ) then put("err n"); end if;
      if not Equal( o, l**puiss ) then put("err o"); end if;

    end loop;

    New_Line;
    Put_Line("test / ");

    for puiss in 1 .. 200 loop
      if puiss mod 50=0 then put(integer'image(puiss)); end if;

      for ik in 3..10 loop
      for il in 11..23 loop

        Fill( k, Multi(ik) );
        Fill( l, Multi(il) );
        Fill( j, k*l );

        Fill( m, j**puiss );
        Fill( n, k**puiss );
        Fill( o, l**puiss );

        if not (
          Test_egalite(  m/n, o, " m/n=o ") ) then
          put("ik="); put(integer'image(ik)); new_line;
          put("il="); put(integer'image(il)); new_line;
          test_aff("m",m,true);
          test_aff("n",n,true);
          put("kl KO"); return;
        end if;
      end loop;
      end loop;

    end loop;

    New_Line;
    Put_Line("autre test /");

    Fill( k, Multi(123) );
    Fill( l, Multi(456) );
    Fill( j, k*l );

    for puiss in 50 .. 300 loop

      Fill( m, j**puiss );
      Fill( n, k**puiss );
      Fill( o, l**puiss );
      Fill( p, n+o );

      if puiss mod 50=0 or not (
        Test_egalite(  m/n, o, " m/n=o ") and
        Test_egalite(  ( m/n ) / (o/2) , Multi( 2), " (m/n)/(o/2)=2 ") and
        Test_egalite(  ( o/2 ) / (o/2) , Multi( 1), " (o/2)/(o/2)=1 ") and
        Test_egalite(  ( m/n ) / o  , Multi( 1), " (m/n)/o=1 ") and
        Test_egalite( m , n*o , " m=n*o ") and
        Test_egalite( ((m-n*n-o)*2)-m*2+2*n**2+o+o , Multi(0) , " err3 ") and
        Test_egalite( m/(-m) , Multi(-1) , " err4 ") and
        Test_egalite( m , (m/p) * p + (m rem p) , " div et rem ")
      ) then

        put(integer'image(puiss));

      end if;
    end loop;
    New_Line;

    Pause;

    Test_aff( "m (=j^300) vaut...", m );

    Pause;

    Put_Line("m=m  " & boolean'image( Equal( m,m ) ));
    Put_Line("m=j  " & boolean'image( Equal( m,j ) ));
    Put_Line("j=m  " & boolean'image( Equal( j,m ) ));
    Put_Line("m<m  " & boolean'image( m<m ));
    Put_Line("j<m  " & boolean'image( j<m ));
    Put_Line("m>m  " & boolean'image( m>m ));
    Put_Line("j>m  " & boolean'image( j>m ));
    Put_Line("m<=m " & boolean'image( m<=m ));
    Put_Line("j<=m " & boolean'image( j<=m ));
    Put_Line("m<=j " & boolean'image( m<=j ));
    Put_Line("m>=m " & boolean'image( m>=m ));
    Put_Line("j>=m " & boolean'image( j>=m ));
    Put_Line("m>=j " & boolean'image( m>=j ));
    Put_Line("Odd(m)  " & boolean'image( Odd(m)  ));
    Put_Line("Even(m) " & boolean'image( Even(m) ));
    Put_Line("1234567890 < 1234567891  " & boolean'image(
             Val("1234567890")<Val("1234567891") ));
    Put_Line("1234567891 < 1234567890  " & boolean'image(
             Val("1234567891")<Val("1234567890") ));
    Pause;

    loop
      begin
        Put("Nombres de Syracuse, nombre de depart (ch vide: sortie):");
        Get_line(s,ls);
        exit when ls=0;
        Syracuse(Val(s(1..ls)));
      exception
        when others=> Put_Line("Erreur!");
      end;
    end loop;

  end Test_Int;