fix comparison two string : [a;b] == [c a b]
[scilab.git] / scilab / modules / differential_equations / src / cpp / checkodeerror.cpp
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2011 - DIGITEO - Cedric DELAMARRE
4 *
5 * This file must be used under the terms of the CeCILL.
6 * This source file is licensed as described in the file COPYING, which
7 * you should have received as part of this distribution.  The terms
8 * are also available at
9 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10 *
11 */
12 /*--------------------------------------------------------------------------*/
13
14 extern "C" {
15 #include "checkodeerror.h"
16 #include "sciprint.h"
17 #include "localization.h"
18 #include "configvariable_interface.h"
19 }
20 // return 0 = ok, return 1 = error, return 2 = warning
21 int checkOdeError(int meth, int istate)
22 {
23     switch (meth)
24     {
25         case 0 : // lsoda
26         case 3 : // lsodar
27         {
28             if (istate == -7)
29             {
30                 sciprint(_("Work space insufficient to finish (see messages).\n"));
31                 return 1;
32             }
33         }
34         case 1 : // lsode | lsodi (adams)
35         case 2 : // lsode | lsodi (stiff)
36         {
37             if (istate == -1)
38             {
39                 sciprint(_("Excess work done on this call (perhaps wrong jacobian type).\n"));
40                 return 1;
41             }
42             else if (istate == -2)
43             {
44                 sciprint(_("Excess accuracy requested (tolerances too small).\n"));
45                 return 1;
46             }
47             else if (istate == -3)
48             {
49                 sciprint(_("Illegal input detected (see printed message).\n"));
50                 return 1;
51             }
52             else if (istate == -4)
53             {
54                 sciprint(_("Repeated error test failures (check all inputs).\n"));
55                 return 1;
56             }
57             else if (istate == -5)
58             {
59                 sciprint(_("Repeated convergence failures (perhaps bad jacobian supplied or wrong choice of jacobian type or tolerances).\n"));
60                 return 1;
61             }
62             else if (istate == -6)
63             {
64                 sciprint(_("Error weight became zero during problem. (solution component i vanished, and atol or atol(i) = 0.)\n"));
65                 return 1;
66             }
67             else if (istate == -7) // only used with impl (lsodi)
68             {
69                 sciprint(_("The user-supplied subroutine res set its error flag (ires = 3) despite repeated tries by lsodi to avoid that condition.\n"));
70                 return 1;
71             }
72             else if (istate == -8) // only used with impl (lsodi)
73             {
74                 sciprint(_("istate was 0 on input but lsodi was unable to compute the initial value of dy/dt.\n"));
75                 return 1;
76             }
77             break;
78         }
79         case 4 : // lsdisc (discrete)
80         {
81             if (istate < 0) // from lsdisc.f :
82             {
83                 // istate = 2 if lsdisc was successful, negative otherwise...
84                 return 1;
85             }
86             break;
87         }
88         case 5 : // lsrgk (rk)
89         {
90             if (istate == -1) // from lsrgk.f
91             {
92                 return 1;
93             }
94             break;
95         }
96         case 6 : // rkf45 (rkf)
97         {
98             switch (istate)
99             {
100                 case 3:
101                 {
102                     if (getWarningMode())
103                     {
104                         sciprint(_("Integration was not completed because relative error tolerance was too small. rerr has been increased appropriately for continuing.\n"));
105                     }
106                     return 2;
107                 }
108                 case 4:
109                 {
110                     if (getWarningMode())
111                     {
112                         sciprint(_("Integration was not completed because more than 3000 derivative evaluations were needed. This is approximately 500 steps.\n"));
113                     }
114                     return 2;
115                 }
116                 case 5:
117                 {
118                     sciprint(_("Integration was not completed because solution vanished making a pure relative error test impossible. Must use non-zero aerr to continue. Using the one-step integration mode for one step is a good way to proceed.\n"));
119                     return 1;
120                 }
121                 case 6:
122                 {
123                     sciprint(_("Integration was not completed because requested accuracy could not be achieved using smallest allowable stepsize. User must increase the error tolerance before continued integration can be attempted.\n"));
124                     return 1;
125                 }
126                 case 7:
127                 {
128                     sciprint(_("It is likely that rkf45 is inefficient for solving this problem. Too much output is restricting the natural stepsize choice. Use the one-step integrator mode.\n"));
129                     return 1;
130                 }
131                 case 8:
132                 {
133                     sciprint(_("invalid input parameters : atol and rtol must be greater than 0.\n"));
134                     return 1;
135                 }
136                 default :
137                     break;
138             }
139             break;
140         }
141         case 7 : // rksimp (fix)
142         {
143             if (istate == 3)
144             {
145                 return 1;
146             }
147             else if (istate == 4)
148             {
149                 sciprint(_("Inappropriate error tolerance.\n"));
150                 return 1;
151             }
152             break;
153         }
154     }
155     return 0;
156 }
157
158 int checkDasslError(int idid)
159 {
160     switch (idid)
161     {
162         case 4 ://Only used in dasrt
163         {
164             //One or more root found at t
165             return 2;
166         }
167         case 3 ://The integration to TOUT was successfully completed (T=TOUT) by
168         {
169             //stepping past TOUT. Y,ydot are obtained by interpolation.
170             return 0;
171         }
172         case 2 : //The integration to TSTOP was successfully completed (T=TSTOP)
173         {
174             return 2;
175         }
176         case 1 : //A step was successfully taken in the intermediate-output mode.
177         {
178             //The code has not yet reached TOUT.
179             return 0;
180         }
181         case -1 : //A large amount of work has been expended (About 500 steps)
182         {
183             if (getWarningMode())
184             {
185                 sciprint(_("To many steps necessary to reached next required time discretization point. Change discretisation of time vector t or decrease accuracy.\n"));
186             }
187             return 2;
188         }
189         case -2 : //The error tolerances are too stringent.
190         {
191             sciprint(_("The error tolerances are too stringent.\n"));
192             return 1;
193         }
194         case -3 :
195         {
196             //The local error test cannot be satisfied because you specified
197             //a zero component in ATOL and the corresponding computed solution
198             //component is zero. Thus, a pure relative error test is impossible
199             //for this component.
200             if (getWarningMode())
201             {
202                 sciprint(_("Atol and computed test value are zero.\n"));
203             }
204             return 2;
205         }
206         case -5 : // only used in daskr
207         {
208             // There were repeated failures in the evaluation
209             // or processing of the preconditioner (in JAC).
210             sciprint(_("Cannot evaluate the preconditioner.\n"));
211             return 1;
212         }
213         case -6 : //Repeated error test failures on the last attempted step.
214         {
215             if (getWarningMode())
216             {
217                 sciprint(_("A singularity in the solution may be present.\n"));
218             }
219             return 2;
220         }
221         case -7 : //The corrector could not converge.
222         {
223             if (getWarningMode())
224             {
225                 sciprint(_("May be inaccurate or ill-conditioned JACOBIAN.\n"));
226             }
227             return 2;
228         }
229         case -8 : //The matrix of partial derivatives is singular.
230         {
231             sciprint(_("Singular partial derivatives matrix (may be redundant equations).\n"));
232             return 1;
233         }
234         case -9 : //The corrector could not converge.
235         {
236             //There were repeated error test failures in this step.
237             if (getWarningMode())
238             {
239                 sciprint(_("Either ill-posed problem or discontinuity or singularity encountered.\n"));
240             }
241             return 2;
242         }
243         case -10 :
244         {
245             if (getWarningMode())
246             {
247                 sciprint(_("External ''res'' return many times with ires=-1.\n"));
248             }
249             return 2;
250         }
251         case -11 : //IRES equal to -2 was encountered and
252         {
253             //control is being returned to the calling program.
254             sciprint(_("Error in external ''res''.\n"));
255             return 1;
256         }
257         case -12 : //DDASSL, dasrt or daskr failed to compute the initial YPRIME.
258         {
259             sciprint(_("failed to compute the initial Ydot.\n"));
260             return 1;
261         }
262         case -13 : // only used in daskr
263         {
264             // An unrecoverable error was encountered inside the user's PSOL routine,
265             // and control is being returned to the calling program.
266             sciprint(_("Error in external psol.\n"));
267             return 1;
268         }
269         case -14 : // only used in daskr
270         {
271             // The Krylov linear system solver could not achieve convergence.
272             sciprint(_("The Krylov linear system did not converge.\n"));
273             return 1;
274         }
275         case -33 :
276         {
277             //The code has encountered trouble from which
278             //it cannot recover. A message is printed
279             //explaining the trouble and control is returned
280             //to the calling program. For example, this occurs
281             //when invalid input is detected.
282             if (getWarningMode())
283             {
284                 sciprint(_("encountered trouble.\n"));
285             }
286             return 2;
287         }
288     }
289
290     return 1;
291 }
292