Next: libsimsort
Up: libsim
Previous: libsimswedish
libsimmath
NAME
libsimmath - additonal mathematical utilities
DESCRIPTION
The following operations are offering facilities for
mathematical realted problems, some often used functions,
conveninet summation of arrays, and some support for random
number generation.
EXAMPLE
external real procedure Sigma2;
long real array A(1:1000);
long real Variance,Mean,Sum;
integer N,ix;
N:=init; N:=min(N,1000);
for ix:=1 step 1 until N do
A(ix):=inreal;
Variance:=Sigma2(Mean,Sum,A,N);
Outtext( Variance,Mean,Sum,N"); outimage;"
OutReal(Variance,5,10);OutReal(Mean,5,10);
OutReal(Sum,5,10);OutReal(N,5,10); outimage;
AUTHOR
Various people at QZ and FOA, Stockholm.
DETAILED INTERFACE
ILog
integer procedure ILog(X);
long real X;
Useful when editing numbers into texts. Returns
Log10(Abs(X))+1, i.e. integer digits in X (excluding sign),
if Abs(X)>=1, 0 if X=0 and number of leading zero decimals,
if Abs(X)<1
ILog2i
integer procedure ILog2i (x);
long real x;
Returns ln(x)/ln(2), power of 2 for x, rounded to integer.
ISum
integer procedure ISum(IA,N);
integer array IA;
integer N; ! Size of array IA (1:N) ;
Return Sum of integer array IA (1:N).
RSum
long real procedure RSum(RA,N);
real array RA;
integer N; ! Size of array RA (1:N) ;
Return Sum of real array RA (1:N).
LSum
long real procedure LSum(LA,N);
long real array LA;
integer N; ! Size of array LA (1:N) ;
Return Sum of long real array LA (1:N).
Sigma2
real procedure Sigma2(Mean,Sum,RA,N);
name Mean,Sum; ! - output parameters;
real Mean; ! - mean value (Sigma2 returns Variance);
real Sum; ! - sum of elements RA(1:N) ;
real array RA; integer N; ! input paramters, RA(1:N) ;
SIGMA2 calculates the variance, mean value and sum of a real
array RA, from RA(1) to RA(N).
SigMean
procedure SigMean(Sigma2,Mean,K,XK1);
name Sigma2,Mean,K; ! In/Out parameters ;
long real Sigma2; ! In: previous variance, Out: updated
taking Xk1 into account;
long real Mean; ! In: previous mean, Out: updated
taking Xk1 into account;
integer K; ! In: Number of observations, Out:
incremented;
real XK1; ! Input: The new observation of X,
observation K+1;
Calculates Mean-value and Variance for a statistical
material in an iterative fashion. Given mean and variance
for k operations and the new observation k+1, mean and
variance is updated. Example of use: begin
external procedure SigMean;
long real SigmaAccum,MeanAccum;integer Obs; ! Updated
by SigMean;
real X; ! the just found observation. ;
long real StandDev; ! Calculated when all observations
known;
Obs:= 0; mean:= 0; sigma2:= 0; ! Initialization ;
inimage; ! One value per input line;
while enfile do
begin
X:=inreal; ! The new observation, X(Obs+1) ;
SigMean(SigmaAccum,MeanAccum,Obs,x);
! Updates SigmaAccum,MeanAccum and Obs;
end while;
StandDev:= Sqrt(SigmaAccum*Obs/(Obs-1));
Outtext( Mean, Variance, Std.dev. Observations:");
Outimage;"
Outreal(MeanAccum,5,20); Outreal(SigmaAccum,5,20);
Outreal(StandDev,5,20); Outint(Obs,10); Outimage;
end;
Note: compared to Sigma2, SigMean may lose some precision.
The advantage of using SigMean over Sigma2 is that only one
observation is need at the time rather than all observations
(possibly many) needed by Sigma2.
Scramble
procedure Scramble(IntArray,Bottom,Top,U);
name U; ! Integer variable to be updated;
integer array IntArray; integer
Bottom,Top;!IntArray(Bottom:Top) shuffled;
integer U; ! Random seed, as for other random drawing
procedures. Init to odd no.;
Scramble performs a Random permutation of elements in the
integer array IntArray in the interval (Bottom:Top).
class PerGen
class PerGen(A,N);
integer array A; integer N; ! Array to permute A(1:N);
Class PerGen generates all the possible permutations of the
contents in integer array a(1:N), one at a time. PerGen
objects works as iterators, 'Call' the object to generate
next permutation in a. The permutations will be generated
in such manner that the last elements of A will change most
slowly. Example: begin
external class PerGen;
integer array a(1:3);
ref (PerGen) pg;
a(1):=1; a(2):=2; a(3):=3;
pg:- new PerGen(a,n);
while pg.Cycles < 2 do ! consider first cycle only ;
begin
outint(a(1),3); outint(a(2),3); outint(a(3),3);
outimage;
Call(pg); ! generate new permutation;
end;
end - Result (one cycle of 6 permutations):
1 2 3 / 2 1 3 / 3 1 2 / 1 3 2 / 2 3 1 / 3 2
1
Note that permutations are generated systematically and
that the order will be REVERSED when one N! cycle is
completed. Thus for N = 2 then result will be (if A(1)=1,
A(2)=2 initially): (1 2) (2 1) / (2 1) (1 2) / (1 2) (2 1)
etc. (2 permutations per cycle).
OPERATIONS
Cycles
integer procedure Cycles;
Return the current permutation cycle number, 1,2,... The
number is increased after N! permutations have been
generated (including the inital one). Cycle is returning 2
when A contains the first permutation of the second cycle
(which is equal to the last permutation of the first cycle,
since the order of permutations are reversed with each
cycle).