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

TEST: 174-1-3-T076-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
(48, 18) Use of possibly unassigned local variable 'left_n1'.
(48, 18) Use of possibly unassigned local variable 'left_n1'.
(84, 3) The variable 'right_j1' is assigned but its value is never used.
PASSED Compiler: 1.2.8.0
Date, time: 2010.08.06, 22:22
Compilation: SUCCESS
Execution: SUCCESS
(48, 18) Use of possibly unassigned local variable 'left_n1'.
(48, 18) Use of possibly unassigned local variable 'left_n1'.
(84, 3) The variable 'right_j1' is assigned but its value is never used.
(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  
135  
136  
137  
138  
139  
140  
141  
142  
143  
144  
145  
146  
147  
148  
149  
150  
151  
152  
153  
154  
155  
156  
157  
158  
159  
160  
161  
162  
163  
164  
165  
166  
167  
168  
169  
170  
171  
172  
173  
 (**   
  * 17. Math extensions.  
  * 17.4. Operators  
  * 17.4.2. Binary  
  *   
  * Positive test: Binary plus + indexing  
  * scalar + array  
  *)  
   
 module Main;  
   
 type mi = array {math} *,* of integer;  
 type mr = array {math} *,* of real;  
 type mc = array {math} *,* of cardinal;  
 type mb = array {math} *,* of boolean;  
   
 type iind = array {math} * of integer;  
 type bind = array {math} * of boolean;  
   
   
 (******************************)  
 procedure {public} f1 (left : array {math} *,* of integer; right: integer;   
      left_n_r0: array {math} * of integer; left_n_r1: array {math} * of boolean ) : mi;  
 var  
      i0, i1, left_n0, left_n1, right_n0, right_n1, left_j1 : integer;  
      res : mi;  
 begin  
   
     left_n0 := len(left_n_r0, 0);  
     if ( len(left_n_r1, 0) # len(left, 1) )  
     then  
         return nil;  
     end;  
   
     for i0 := 0 to len(left_n_r1, 0) - 1  
     do  
           if ( left_n_r1[i0] )  
         then  
             left_n1 := left_n1 + 1;  
         end;  
     end;  
   
     res := new mi(left_n0,left_n1);  
   
     for i0 := 0 to left_n0 - 1  
     do  
           left_j1 := 0;  
           for i1 := 0 to left_n1 - 1   
           do  
                while ( ~left_n_r1[left_j1] )   
                do  
                     left_j1 := left_j1 + 1;  
                end;  
   
                res[i0,i1] := right  
                     + left[left_n_r0[i0], left_j1];  
                left_j1 := left_j1 + 1;  
           end;  
     end;  
   
     return res;  
 end f1;  
           
 (******************************)          
 procedure {public} f2 (left : array {math} *,* of integer; right: real;   
      left_n_r0: array {math} * of integer;   
      left_n_r1_frominteger; left_n_r1_wasToWritten: boolean; left_n_r1_tointeger; left_n_r1_byinteger ) : mr;  
 var  
      i0, i1, left_n0, left_n1, right_n0, right_n1, right_j1 : integer;  
      res : mr;  
 begin  
     if ( ~left_n_r1_wasToWritten )  
     then  
         left_n_r1_to := integer(len(left,1) - 1);  
     end;  
   
     left_n0 := len(left_n_r0, 0);  
     left_n1 := ((left_n_r1_to - left_n_r1_fromdiv left_n_r1_by) + 1;  
   
     res := new mr(left_n0,left_n1);  
   
     for i0 := 0 to left_n0 - 1  
     do  
           right_j1 := 0;  
           for i1 := 0 to left_n1 - 1   
           do  
                res[i0,i1] := right   
                     + left[left_n_r0[i0], left_n_r1_from + (i1 * left_n_r1_by)];  
           end;  
     end;  
   
     return res;  
 end f2;  
 (******************************)  
   
   
 var  
      ai1 : array {math} 2, 3 of integer;  
      ai2, ai3, ai3_prove : mi;  
      ar1 : array {math} 2, 3 of real;  
      ar2, ar3, ar4, ar3_prove : mr;  
      ac1 : array {math} 2, 3 of cardinal;  
      ac2, ac3, ac3_prove : mc;  
        
      bi1, bi2 : iind;  
      bb1, bb2 : bind;  
      r1, r2 : range;  
        
      i, j : integer;  
        
      ki : integer;  
      kr : real;  
        
 begin       
        
      ai1 := [[-1, 2, -3], [4, -5, 6]];  
      ai2 := [[-23, -24, 35], [-3, 25, 45]];  
      ar1 := [[1.3, -2.1, 3.4], [-4.1, 5.2, -6.7]];  
      ar2 := [[6.1, +3.8, 2.6], [+4.1, -5.1, -3.1]];  
      ac1 := [[1, 2, 3], [4, 5, 6]];  
      ac2 := [[4, 3, 1], [8, 2, 16]];  
        
      bi1 := [1, 0, 1, 2];  
      bi2 := [1, 0, 0];  
      bb1 := [falsetruetrue];  
      bb2 := [truetruefalse];  
      r1 := 1..2;  
      r2 := 0..2 by 2;  
        
      ki := 3;  
      ai3 := ki + ai1[bi2, bb1];  
      kr := 1.3;  
      ar3 := kr + ai1[bi2, r2];  
        
      ai3_prove := f1(ai1, ki, bi2, bb1);  
      ar3_prove := f2(ai1, kr, bi2, 0, true, 2, 2);  
        
      if (len(ai3, 0) # len(ai3_prove, 0)) or (len(ai3, 1) # len(ai3_prove, 1))  
      then  
           halt(0);  
      end;  
        
      for i := 0 to len(ai3, 0) - 1  
      do  
           for j := 0 to len(ai3, 1) - 1  
           do  
                if ai3[i, j] # ai3_prove[i, j]   
                then   
                     halt(0);  
                end;  
           end;  
      end;  
        
      if (len(ar3, 0) # len(ar3_prove, 0)) or (len(ar3, 1) # len(ar3_prove, 1))  
      then  
           halt(0);  
      end;  
        
      for i := 0 to len(ar3, 0) - 1  
      do  
           for j := 0 to len(ar3, 1) - 1  
           do  
                if ar3[i, j] # ar3_prove[i, j]  
                then   
                     halt(0);  
                end;  
           end;  
      end;  
   
      halt(1);  
        
 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