Home
   News
   About the project
   Language
   Compiler download
   Test suite
   Blog on the programming model
   Zonnon @ OCP Forum
   Collection of examples

TEST: 17EXBICONJUGATEGRADMETHOD-T

category

status

Compilation and execution results for Windows (first) and Mono (second)
PASSED Compiler: 1.2.8.0
Date, time: 2010.08.06, 18:06
Compilation: SUCCESS
Execution: SUCCESS
PASSED Compiler: 1.2.8.0
Date, time: 2010.08.06, 22:22
Compilation: SUCCESS
Execution: SUCCESS
(0, 0) Assembly reference not resolved: System.Configuration, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a.

code

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
32  
33  
34  
35  
36  
37  
38  
39  
40  
41  
42  
43  
44  
45  
46  
47  
48  
49  
50  
51  
52  
53  
54  
55  
56  
57  
58  
59  
60  
61  
62  
63  
64  
65  
66  
67  
68  
69  
70  
71  
72  
73  
74  
75  
76  
77  
78  
79  
80  
81  
82  
83  
84  
85  
86  
87  
88  
89  
90  
91  
92  
93  
94  
95  
96  
97  
98  
99  
100  
101  
102  
103  
104  
105  
106  
107  
108  
109  
110  
111  
112  
113  
114  
115  
116  
117  
118  
119  
120  
121  
122  
123  
124  
125  
126  
127  
128  
129  
130  
131  
132  
133  
134  
 (*************************************************************************  
 Solving a system of linear equations Ax = b.   
   
 Solving a SLE (system of linear equations) Ax = b using biconjugate gradient method,  
 where A is a real square matrix;  
 The preconditioner is the diagonal part of A.  
   
 Method description: http://en.wikipedia.org/wiki/Biconjugate_gradient_method  
                     Belov S.A., Zolotykh N.Y. "Numerical methods of linear algebra" (in russian)  
   
 Author: Nina Gonova                       
 Last change: 13.04.2009  
 **************************************************************************)  
   
 module BiConjugateGradMethod;  
   
 type {public} TypeOfArray = real;  
 type {publicref} Vector = array {math} * of TypeOfArray;  
 type {publicref} Matrix = array {math} *, * of TypeOfArray;  
   
 const eps = 0.01;  
   
 procedure {public} Solution(A: Matrix; b, x0: Vector) : Vector;  
 var  
      x : Vector; (*x is the solution*)  
      MInv : Vector; (*MInv = M^(-1), where M is preconditioner*)  
      r, rw : Vector; (*biorthogonal residuals*)  
      p, pw : Vector; (*biconjugate directions*)  
      q, z, zw : Vector; (*auxiliary variable*)  
      mu, nu, alpha, beta: TypeOfArray; (*auxiliary variable*)  
      i, n : integer; (*n = number of lines of A = number of columns of A*)  
   
 begin  
      n := len(A);  
   
      x := new Vector(n);  
      q := new Vector(n);  
      r := new Vector(n);  
      rw := new Vector(n);  
      p := new Vector(n);  
      pw := new Vector(n);  
      MInv := new Vector(n);  
      z := new Vector(n);   
      zw := new Vector(n);  
      for i := 0 to n - 1 do  
           MInv[i] := 1 / A[i, i];  
      end;  
        
      (*initialization*)  
      x := x0;  
      r := b - A * x;  
      rw := r;  
      p := MInv .* r;  
      pw := rw .* MInv;  
      z := p;  
      zw := pw;  
      mu := rw +* z;   
        
      loop  
           if abs(r) < eps then exitend;  
             
           q := A * p;  
           alpha := mu / (pw +* q);  
           r := r - alpha * q;  
           rw := rw - alpha * pw * A;  
           x := x + alpha * p;       
           z := MInv .* r;  
           zw := rw .* MInv;  
           nu := rw +* z;  
           beta := nu / mu;  
           p := z + beta * p;  
           pw := zw + beta * pw;  
           mu := nu;  
             
      end;  
   
      return x;  
   
 end Solution;  
   
 begin  
   
 end BiConjugateGradMethod.  
   
 module Main;  
   
 import   
      BiConjugateGradMethod;  
   
 var  
      A : BiConjugateGradMethod.Matrix;   
      i, j: integer;  
      n: integer;  
      x, x0, b, r: BiConjugateGradMethod.Vector;  
      q : real;  
   
 begin  
      n := 4;  
   
      A := new BiConjugateGradMethod.Matrix(n, n);  
      b := new BiConjugateGradMethod.Vector(n);  
      x0 := new BiConjugateGradMethod.Vector(n);  
        
      q := 3.4;  
      for i := 0 to n - 1 do  
           for j := 0 to n - 1 do  
                A[i, j] := q * q + i + j - q * i + 2.3 / q * j;  
           end;  
      end;  
        
      q := 2.18;  
      for i := 0 to n - 1 do  
           b[i] := (q + 2*i - 4) / q;  
      end;  
   
      for i := 0 to n - 1 do  
           x0[i] := 0.;  
      end;  
        
      x := BiConjugateGradMethod.Solution(A, b, x0);  
        
      if x # nil   
      then       
           r := b - A * x;  
           if (abs(r) < 0.01)   
           then halt(1);  
           else halt(0);  
           end;  
      else  
           halt(0);  
      end;  
        
 end Main.  
   

information

  • PASSED - overall positive decision about the test
  • NOT PASSED - overall negative decision about the test
  • SUCCESS - compilation / execution successful
  • ERROR - compilation failed with normal syntax or semantic error
  • ABORT - compilation failed because of an internal compiler error
  • NOT RUN - the test was not / not supposed to be executed
  • FAIL - execution failed
Copyright © 2010 ETH Zurich, Switzerland