Voordelen

Begin jaren negentig heeft computeralgebra-technologie een dusdanig niveau bereikt dat enkele gebruiksvriendelijke wiskunde-omgevingen met ingebouwde grafische, numerieke, symbolische en tekstverwerkingsfaciliteiten bestaan. Koplopers en directe concurenten van elkaar zijn Maple en Mathematica. Wiskunde bedrijven gaat in deze systemen bijna als volgt:

In[1]:= Solve[Problem]

Out[1]= Answer

Het belangrijkste voordeel van computeralgebra-gebruik is de mogelijkheid om grote berekeningen te kunnen doen die met pen en papier alleen niet of maar zeer moeizaam te doen zouden zijn. Bijvoorbeeld, de controle dat

gaat met Maple in een vloek en een zucht:

> settime := time():   # start tijdopname
> f := sin( n*z*sqrt(x^2+y^2+z^2) / sqrt(y^2+z^2) ) / 
>   sqrt(x^2+y^2+z^2);

> radnormal( diff( diff(f,x$2) + diff(f,y$2) + diff(f,z$2),
>   x$2 ) + n^2 * ( diff(f,x$2) + diff(f,y$2) ) );

cpu_time = (time()-settime) * seconds; # rekentijd

Tweede misschien wel even belangrijk voordeel is de gemakkelijke toegang die een computeralgebra-systeem tot geavanceerde wiskunde geeft. De volgende integraal is bijvoorbeeld niet met traditionele integratie technieken uit te rekenen. Het Risch algoritme in Maple is noodzakelijk:

> Int( (7*x^13+10*x^8+4*x^7-7*x^6-4*x^3-4*x^2+3*x+3) /
>    (x^14-2*x^8-2*x^7-2*x^4-4*x^3-x^2+2*x+1), x ):
> " = value(");

Met een computeralgebra-systeem is het gemakkelijker geworden om te experimenteren met formules en om vermoedens op te sporen of uit te testen. Een voorbeeld (zie [6]): gegeven een rijtje getallen , definiëren we een rijtje -en recursief via

en

.

We vragen ons af of er een gesloten formule bestaat. We berekenen eerste enkele -en:

> f[0] := 1;

> for n from 1 to 8 do
>   f[n] := expand(g[n]*s^2 - 
>                  sum('binomial(n,k)*f[n-k]', k=1..n));
> od;

Met in het achterhoofd de driehoek van Pascal suggereren bovenstaande uitkomsten dat

Je kunt ook je voordeel er mee doen om een computeralgebra-systeem te gebruiken voor het genereren van FORTRAN of C code.

> f := Pi*ln(x^2)-sqrt(2)*ln(x^2)^2;

> C(f);

t0 = 0.3141592653589793E1*log(x*x)-sqrt(2.0)*pow(log(x*x),2.0);

> C(f, optimized);

      t1 = x*x;
      t2 = log(t1);
      t4 = sqrt(2.0);
      t5 = t2*t2;
      t7 = 0.3141592653589793E1*t2-t4*t5;

> trigvalues := proc(x)
>   local i,trigs: global Digits:
>   if not type( x, numeric ) then
>      ERROR( `non-numeric input` )
>   elif Digits < 15 then 
>      Digits := 15 
>   fi:
>   trigs := array( 1..4, sparse,
>     [ (1)=sin(x), (2)=cos(x), (3)=tan(x) ] ):
>   for i to 4 do print( trigs[i] ) od:
>   trigs
> end:
> fortran( trigvalues, precision=single );

      subroutine trigvalues(x,crea_par)
      real x
      real crea_par(4)

      integer i
      real trigs(4)

      common/global/Digits
      integer Digits

        if ( .not. type(x,numeric)) then
          write(6,*) 'non-numeric input'
          call exit(0)
        else 
          if (Digits .lt. 15) then
            Digits = 15
          endif
        endif
        trigs(1) = sin(x)
        trigs(2) = cos(x)
        trigs(3) = tan(x)
        trigs(4) = 0
        do 1000 i = 1,4,1
          write(6,*) trigs(i)
1000    continue
        crea_par(1) = trigs(1)
        crea_par(2) = trigs(2)
        crea_par(3) = trigs(3)
        crea_par(4) = trigs(4)
        return
      return
      end