Annotation of OpenXM_contrib/PHC/Ada/Continuation/continuation_parameters_io.adb, Revision 1.1.1.1
1.1 maekawa 1: with integer_io; use integer_io;
2: with Communications_with_User; use Communications_with_User;
3: with Standard_Floating_Numbers; use Standard_Floating_Numbers;
4: with Standard_Floating_Numbers_io; use Standard_Floating_Numbers_io;
5: with Numbers_io; use Numbers_io;
6: with Characters_and_Numbers;
7: with Continuation_Parameters; use Continuation_Parameters;
8:
9: package body Continuation_Parameters_io is
10:
11: -- AUXILIARIES :
12:
13: function Predictor_Banner ( pred_type : natural ) return string is
14:
15: -- DESCRIPTION :
16: -- Returns banner for the corresponding predictor type.
17:
18: ss : constant string := "( x:Sec,t:Rea )";
19: sc : constant string := "( x:Sec,t:Com )";
20: sg : constant string := "( x:Sec,t:Geo )";
21: ts : constant string := "( x:Tan,t:Rea )";
22: tc : constant string := "( x:Tan,t:Com )";
23: tg : constant string := "( x:Tan,t:Geo )";
24: hs : constant string := "( x:Her,t:Rea )";
25: uu : constant string := " no predictor ";
26:
27: begin
28: case pred_type is
29: when 0 => return ss;
30: when 1 => return sc;
31: when 2 => return sg;
32: when 3 => return ts;
33: when 4 => return tc;
34: when 5 => return tg;
35: when 6 => return hs;
36: when others => return uu;
37: end case;
38: end Predictor_Banner;
39:
40: procedure Read_Positive_Float ( f : in out double_float ) is
41: begin
42: loop
43: Read_Double_Float(f);
44: exit when f > 0.0;
45: put("Zero or negative value not allowed, try again : ");
46: end loop;
47: end Read_Positive_Float;
48:
49: -- INFORMATION BALLOONS :
50:
51: procedure Condition_Info is
52:
53: i : array(1..4) of string(1..65);
54:
55: begin
56: i(1):=" This global parameter can be used to tune the parameters";
57: i(2):="according to the general expectancy of how difficult the solution";
58: i(3):="paths will be. Low values of this parameter lead to a loose path";
59: i(4):="tracking, whereas higher values tighten up the path-following. ";
60: for j in i'range loop
61: put_line(i(j));
62: end loop;
63: end Condition_Info;
64:
65: procedure Number_of_Paths_Info is
66:
67: i : array(1..9) of string(1..65);
68:
69: begin
70: i(1):=" In simultaneous path-following, the same discretization for the";
71: i(2):="values of the continuation parameter is used for a number of";
72: i(3):="paths. Clustering of solution paths is checked during";
73: i(4):="continuation for the number of paths that are followed";
74: i(5):="simultaneously. ";
75: i(6):=" In sequential path-following, i.e., when this parameter equals";
76: i(7):="one, the step sizes are adjusted according to the difficulty of";
77: i(8):="the current path being followed. In this case, a difficult path";
78: i(9):="does not slow down the continuation for the other ones. ";
79: for j in i'range loop
80: put_line(i(j));
81: end loop;
82: end Number_of_Paths_Info;
83:
84: procedure Max_Steps_Info is
85:
86: i : array(1..3) of string(1..65);
87:
88: begin
89: i(1):=" This parameter bounds the amount of work along a solution path.";
90: i(2):="Continuation for the path being followed stops when the number of";
91: i(3):="steps exceeds this threshold value. ";
92: for j in i'range loop
93: put_line(i(j));
94: end loop;
95: end Max_Steps_Info;
96:
97: procedure Distance_Info is
98:
99: i : array(1..6) of string(1..65);
100:
101: begin
102: i(1):=" Tracking solution paths is organized in two stages. As t<1, no";
103: i(2):="singularities are likely to occur and paths can be tracked more";
104: i(3):="loosely. When t gets close to 1, paths may converge to singular";
105: i(4):="solutions or diverge to infinity, so they have to be tracked more";
106: i(5):="carefully. This distance marks the switch towards the second";
107: i(6):="stage, that is the so-called end game. ";
108: for j in i'range loop
109: put_line(i(j));
110: end loop;
111: end Distance_Info;
112:
113: procedure Extrapolation_Order_Info is
114:
115: i : array(1..5) of string(1..65);
116:
117: begin
118: i(1):=" The direction of a diverging solution path provides a normal to";
119: i(2):="a face of the system that certificates the deficiency. In this";
120: i(3):="polyhedral end game, extrapolation is used to determine winding";
121: i(4):="numbers. When the order of the extrapolator equals zero, then";
122: i(5):="the polyhedral end game is turned off. ";
123: for j in i'range loop
124: put_line(i(j));
125: end loop;
126: end Extrapolation_Order_Info;
127:
128: procedure Re_Run_Info is
129:
130: i : array(1..4) of string(1..65);
131:
132: begin
133: i(1):=" Solution paths may be clustered at the end of the continuation.";
134: i(2):="If the number of re-runs is higher than one, then clustered";
135: i(3):="solution paths are re-computed by following the paths more";
136: i(4):="closely. Setting this value to zero turns off this facility. ";
137: for j in i'range loop
138: put_line(i(j));
139: end loop;
140: end Re_Run_Info;
141:
142: procedure Predictor_Info is
143:
144: i : array(1..11) of string(1..65);
145:
146: begin
147: i( 1):=" We distinguish between predictors for the solution vector x and";
148: i( 2):="the continuation parameter t. The secant predictor for x is";
149: i( 3):="based on linear extrapolation, whereas the tangent predictor uses";
150: i( 4):="the Jacobian matrix to extrapolate. ";
151: i( 5):=" For t, three different predictors are provided. The real";
152: i( 6):="predictor simply augments t with the step size. The complex";
153: i( 7):="predictor takes values in the complex plane to circumvent values";
154: i( 8):="of t for which the corresponding system is badly conditioned.";
155: i( 9):="The geometric predictor generates values for t so that the";
156: i(10):="distances to the target value behave like a geometric series.";
157: i(11):="The latter predictor is useful in a polyhedral end game. ";
158: for j in i'range loop
159: put_line(i(j));
160: end loop;
161: end Predictor_Info;
162:
163: procedure Min_Step_Size_Info is
164:
165: i : array(1..4) of string(1..65);
166:
167: begin
168: i(1):=" This is a lower bound on the step size for the continuation";
169: i(2):="parameter. Continuation for the path being followed stops when a";
170: i(3):="required reduction of the step size yields a step length that is";
171: i(4):="lower than the minimum step size. ";
172: for j in i'range loop
173: put_line(i(j));
174: end loop;
175: end Min_Step_Size_Info;
176:
177: procedure Max_Step_Size_Info is
178:
179: i : array(1..4) of string(1..65);
180:
181: begin
182: i(1):=" This is an upper bound on the step size for the continuation";
183: i(2):="parameter. An expansion of the step size that yields a step";
184: i(3):="length that is larger than this threshold sets the step size to";
185: i(4):="this threshold. ";
186: for j in i'range loop
187: put_line(i(j));
188: end loop;
189: end Max_Step_Size_Info;
190:
191: procedure Reduction_Factor_Info is
192:
193: i : array(1..3) of string(1..65);
194:
195: begin
196: i(1):=" When the corrector does not manage to reach the required";
197: i(2):="accuracy within the allowed number of iterations, the step size";
198: i(3):="will be reduced by multiplication with the reduction factor. ";
199: for j in i'range loop
200: put_line(i(j));
201: end loop;
202: end Reduction_Factor_Info;
203:
204: procedure Expansion_Factor_Info is
205:
206: i : array(1..4) of string(1..65);
207:
208: begin
209: i(1):=" When the corrector has reached the required accuracy within the";
210: i(2):="allowed number of iterations, for a number of consecutive times";
211: i(3):="higher than the expansion threshold, the step size will be";
212: i(4):="enlarged by multiplication by the expansion factor. ";
213: for j in i'range loop
214: put_line(i(j));
215: end loop;
216: end Expansion_Factor_Info;
217:
218: procedure Expansion_Threshold_Info is
219:
220: i : array(1..7) of string(1..65);
221:
222: begin
223: i(1):=" Before enlarging the step size along a path, the number of";
224: i(2):="consecutive successful steps must pass the expansion threshold.";
225: i(3):="A step is successful when the corrector manages to reach the";
226: i(4):="required accuracy within the allowed number of iterations. ";
227: i(5):=" At the end of the path, this threshold bounds the number of";
228: i(6):="consecutive equal guesses of the winding number $m$ before the";
229: i(7):="polyhedral end game can modify it. ";
230: for j in i'range loop
231: put_line(i(j));
232: end loop;
233: end Expansion_Threshold_Info;
234:
235: procedure Number_of_Iterations_Info is
236:
237: i : array(1..7) of string(1..65);
238:
239: begin
240: i(1):=" The corrector stops when the desired accuracy is reached or";
241: i(2):="when it has exhausted its maximum number of iterations. ";
242: i(3):=" A low maximum enforces quadratic convergence and keeps the path";
243: i(4):="tracker close to the solution paths. ";
244: i(5):=" A higher maximum may be needed at the end of the solution path,";
245: i(6):="when quadratic convergence can no longer be obtained due to";
246: i(7):="singularities. ";
247: for j in i'range loop
248: put_line(i(j));
249: end loop;
250: end Number_of_Iterations_Info;
251:
252: procedure Relative_Residual_Info is
253:
254: i : array(1..5) of string(1..65);
255:
256: begin
257: i(1):=" The residual is the norm of the vector obtained after";
258: i(2):="evaluating the current approximation vector in the polynomial";
259: i(3):="system. The corrector stops when the residual divided by the";
260: i(4):="norm of the approximation vector is lower than or equal to the";
261: i(5):="required precision. ";
262: for j in i'range loop
263: put_line(i(j));
264: end loop;
265: end Relative_Residual_Info;
266:
267: procedure Absolute_Residual_Info is
268:
269: i : array(1..4) of string(1..65);
270:
271: begin
272: i(1):=" The residual is the norm of the vector obtained after";
273: i(2):="evaluating the current approximation vector in the polynomial";
274: i(3):="system. The corrector stops when the residual is lower than or";
275: i(4):="equal to the required precision. ";
276: for j in i'range loop
277: put_line(i(j));
278: end loop;
279: end Absolute_Residual_Info;
280:
281: procedure Relative_Correction_Info is
282:
283: i : array(1..4) of string(1..65);
284:
285: begin
286: i(1):=" The correction is the norm of the last vector used to update";
287: i(2):="the current approximation vector. The corrector stops when the";
288: i(3):="correction divided by the norm of the approximation vector is";
289: i(4):="lower than or equal to the required precision. ";
290: for j in i'range loop
291: put_line(i(j));
292: end loop;
293: end Relative_Correction_Info;
294:
295: procedure Absolute_Correction_Info is
296:
297: i : array(1..3) of string(1..65);
298:
299: begin
300: i(1):=" The correction is the norm of the last vector used to update";
301: i(2):="the current approximation vector. The corrector stops when the";
302: i(3):="correction is lower than or equal to the required precision. ";
303: for j in i'range loop
304: put_line(i(j));
305: end loop;
306: end Absolute_Correction_Info;
307:
308: procedure Singular_Info is
309:
310: i : array(1..2) of string(1..65);
311:
312: begin
313: i(1):=" A condition is considered as singular when the condition number";
314: i(2):="of the Jacobian matrix passes the given threshold value. ";
315: for j in i'range loop
316: put_line(i(j));
317: end loop;
318: end Singular_Info;
319:
320: procedure Clustered_Info is
321:
322: i : array(1..3) of string(1..65);
323:
324: begin
325: i(1):=" Two solutions are considered as clustered when the distance";
326: i(2):="between all corresponding components is smaller than the given";
327: i(3):="threshold value. ";
328: for j in i'range loop
329: put_line(i(j));
330: end loop;
331: end Clustered_Info;
332:
333: procedure Infinity_Info is
334:
335: i : array(1..6) of string(1..65);
336:
337: begin
338: i(1):=" A solution is considered to diverge to infinity when its norm";
339: i(2):="passes the given threshold value, in case of affine coordinates,";
340: i(3):="or, in case of projective coordinates, when the added coordinate";
341: i(4):="becomes smaller than the inverse of the threshold value.";
342: i(5):="Continuation for the path being followed stops when it diverges";
343: i(6):="to infinity. ";
344: for j in i'range loop
345: put_line(i(j));
346: end loop;
347: end Infinity_Info;
348:
349: procedure Exit_Info is
350:
351: i : constant string
352: :="By typing 0, the current continuation parameters are used.";
353:
354: begin
355: put_line(i);
356: end Exit_Info;
357:
358: procedure Menu_Predictor ( pred_type : out natural ) is
359:
360: -- DESCRIPTION :
361: -- Shows the menu with available predictors and lets the user choose.
362:
363: ans : character;
364: m : array(0..7) of string(1..65);
365:
366: begin
367: m(0):="MENU with Predictors for Solution x & Continuation Parameter t : ";
368: m(1):=" 0. Secant : linear extrapolation & Real increment for t; ";
369: m(2):=" 1. Secant : based on 2 previous & Complex increment for t; ";
370: m(3):=" 2. Secant : solution values & Geometric series for t; ";
371: m(4):=" 3. Tangent : linear extrapolation & Real increment for t; ";
372: m(5):=" 4. Tangent : based on Jacobi & Complex increment for t; ";
373: m(6):=" 5. Tangent : matrix at solution & Geometric series for t; ";
374: m(7):=" 6. Hermite : cubic extrapolation & Real increment for t; ";
375: for i in m'range loop
376: put_line(m(i));
377: end loop;
378: put("Select predictor by typing number between 0 and 6 : ");
379: Ask_Alternative(ans,"0123456");
380: pred_type := Characters_and_Numbers.Convert(ans);
381: end Menu_Predictor;
382:
383: -- TARGET ROUTINES :
384:
385: procedure put is
386: begin
387: Continuation_Parameters_io.put(Standard_Output);
388: end put;
389:
390: procedure put ( file : in file_type ) is
391:
392: banner_path : constant string := Predictor_Banner(predictor_path_type);
393: banner_endg : constant string := Predictor_Banner(predictor_endg_type);
394:
395: begin
396:
397: put_line(file,"GLOBAL MONITOR : ");
398: put(file," 1. the condition of the homotopy : ");
399: put(file,condition,1); new_line(file);
400: put(file," 2. number of paths tracked simultaneously : ");
401: put(file,block_size,1); new_line(file);
402: put(file," 3. maximum number of steps along a path : ");
403: put(file,max_steps,1); new_line(file);
404: put(file," 4. distance from target to start end game : ");
405: put(file,start_end_game,1,3,3); new_line(file);
406: put(file," 5. order of extrapolator in end game : ");
407: put(file,endext_order,1); new_line(file);
408: put(file," 6. maximum number of re-runs : ");
409: put(file,max_reruns,1); new_line(file);
410:
411: put_line(file,"STEP CONTROL (PREDICTOR) : "
412: & " along path : end game");
413:
414: put(file," 7: 8. type " & banner_path & ":"
415: & banner_endg & " : ");
416: put(file,predictor_path_type,1); put(file," : ");
417: put(file,predictor_endg_type,1); new_line(file);
418: put(file," 9:10. minimum step size : ");
419: put(file,min_path_step_size,1,3,3); put(file," : ");
420: put(file,min_endg_step_size,1,3,3); new_line(file);
421: put(file," 11:12. maximum step size : ");
422: put(file,max_path_step_size,1,3,3); put(file," : ");
423: put(file,max_endg_step_size,1,3,3); new_line(file);
424: put(file," 13:14. reduction factor for step size : ");
425: put(file,reduction_path_factor,1,3,3); put(file," : ");
426: put(file,reduction_endg_factor,1,3,3); new_line(file);
427: put(file," 15:16. expansion factor for step size : ");
428: put(file,expansion_path_factor,1,3,3); put(file," : ");
429: put(file,expansion_endg_factor,1,3,3); new_line(file);
430: put(file," 17:18. expansion threshold : ");
431: put(file,success_path_steps,1); put(file," : ");
432: put(file,success_endg_steps,1); new_line(file);
433:
434: put_line(file,"PATH CLOSENESS (CORRECTOR) : "
435: & " along path : end game");
436:
437: put(file," 19:20. maximum number of iterations : ");
438: put(file,max_path_iter,1); put(file," : ");
439: put(file,max_endg_iter,1); new_line(file);
440: put(file," 21:22. relative precision for residuals : ");
441: put(file,relative_path_residual,1,3,3); put(file," : ");
442: put(file,relative_endg_residual,1,3,3); new_line(file);
443: put(file," 23:24. absolute precision for residuals : ");
444: put(file,absolute_path_residual,1,3,3); put(file," : ");
445: put(file,absolute_endg_residual,1,3,3); new_line(file);
446: put(file," 25:26. relative precision for corrections : ");
447: put(file,relative_path_correction,1,3,3); put(file," : ");
448: put(file,relative_endg_correction,1,3,3); new_line(file);
449: put(file," 27:28. absolute precision for corrections : ");
450: put(file,absolute_path_correction,1,3,3); put(file," : ");
451: put(file,absolute_endg_correction,1,3,3); new_line(file);
452:
453: put_line(file,"SOLUTIONS (TOLERANCES) : "
454: & " along path : end game");
455:
456: put(file," 29:30. inverse condition of Jacobian : ");
457: put(file,tol_path_inverse_condition,1,3,3); put(file," : ");
458: put(file,tol_endg_inverse_condition,1,3,3); new_line(file);
459: put(file," 31:32. clustering of solutions : ");
460: put(file,tol_path_distance,1,3,3); put(file," : ");
461: put(file,tol_endg_distance,1,3,3); new_line(file);
462: put(file," 33:34. solution at infinity : ");
463: put(file,tol_path_at_infinity,1,3,3); put(file," : ");
464: put(file,tol_endg_at_infinity,1,3,3); new_line(file);
465:
466: end put;
467:
468: procedure get_parameter ( k : in natural ) is
469: begin
470: case k is
471: -- GLOBAL MONITOR :
472: when 1 => put(" condition parameter : "); Read_Natural(condition);
473: Continuation_Parameters.Tune(condition);
474: when 2 => put(" number of paths tracked simultaneously : ");
475: Read_Positive(block_size);
476: when 3 => put(" maximum number of steps along a path : ");
477: Read_Positive(max_steps);
478: when 4 => put(" distance from target to start end game : ");
479: Read_Positive_Float(start_end_game);
480: when 5 => put(" order of extrapolator in end game : ");
481: Read_Natural(endext_order);
482: Continuation_Parameters.Tune_Endgm_Pred(endext_order);
483: when 6 => put(" maximum number of re-runs : ");
484: Read_Natural(max_reruns);
485: -- STEP CONTROL (PREDICTOR) :
486: when 7 => Menu_Predictor(predictor_path_type);
487: when 8 => Menu_Predictor(predictor_endg_type);
488: when 9 => put(" minimum step size along the path : ");
489: Read_Positive_Float(min_path_step_size);
490: when 10 => put(" minimum step size at end of path : ");
491: Read_Positive_Float(min_endg_step_size);
492: when 11 => put(" maximum step size along the path : ");
493: Read_Positive_Float(max_path_step_size);
494: when 12 => put(" maximum step size at end of path : ");
495: Read_Positive_Float(max_endg_step_size);
496: when 13 => put(" reduction factor for step size along the path : ");
497: Read_Positive_Float(reduction_path_factor);
498: when 14 => put(" reduction factor for step size at end of path : ");
499: Read_Positive_Float(reduction_endg_factor);
500: when 15 => put(" expansion factor for step size along the path : ");
501: Read_Positive_Float(expansion_path_factor);
502: when 16 => put(" expansion factor for step size at end of path : ");
503: Read_Positive_Float(expansion_endg_factor);
504: when 17 => put(" expansion threshold along the path : ");
505: Read_Positive(success_path_steps);
506: when 18 => put(" expansion threshold at end of path : ");
507: Read_Positive(success_endg_steps);
508: -- PATH CLOSENESS (CORRECTOR) :
509: when 19 => put(" maximum number of iterations along the path : ");
510: Read_Positive(max_path_iter);
511: when 20 => put(" maximum number of iterations at end of path : ");
512: Read_Positive(max_endg_iter);
513: when 21 => put(" relative precision for residual along the path : ");
514: Read_Positive_Float(relative_path_residual);
515: when 22 => put(" relative precision for residual at end of path : ");
516: Read_Positive_Float(relative_endg_residual);
517: when 23 => put(" absolute precision for residual along the path : ");
518: Read_Positive_Float(absolute_path_residual);
519: when 24 => put(" absolute precision for residual at end of path : ");
520: Read_Positive_Float(absolute_endg_residual);
521: when 25 => put(" relative precision for correction along the path : ");
522: Read_Positive_Float(relative_path_correction);
523: when 26 => put(" relative precision for correction at end of path : ");
524: Read_Positive_Float(relative_endg_correction);
525: when 27 => put(" absolute precision for correction along the path : ");
526: Read_Positive_Float(absolute_path_correction);
527: when 28 => put(" absolute precision for correction at end of path : ");
528: Read_Positive_Float(absolute_endg_correction);
529: -- SOLUTIONS (TOLERANCES) :
530: when 29 => put(" inverse condition of Jacobian along the path : ");
531: Read_Positive_Float(tol_path_inverse_condition);
532: when 30 => put(" inverse condition of Jacobian at end of path : ");
533: Read_Positive_Float(tol_endg_inverse_condition);
534: when 31 => put(" clustering of solutions along the path : ");
535: Read_Positive_Float(tol_path_distance);
536: when 32 => put(" clustering of solutions at end of path : ");
537: Read_Positive_Float(tol_endg_distance);
538: when 33 => put(" solution at infinity along the path : ");
539: Read_Positive_Float(tol_path_at_infinity);
540: when 34 => put(" solution at infinity at end of path : ");
541: Read_Positive_Float(tol_endg_at_infinity);
542: when others => null;
543: end case;
544: end get_parameter;
545:
546: procedure get_parameter_with_info ( k : in natural ) is
547:
548: ans : character;
549:
550: begin
551: new_line;
552: case k is
553: when 1 => Condition_Info; -- GLOBAL MONITOR
554: when 2 => Number_of_Paths_Info;
555: when 3 => Max_Steps_Info;
556: when 4 => Distance_Info;
557: when 5 => Extrapolation_Order_Info;
558: when 6 => Re_Run_Info;
559: when 7 | 8 => Predictor_Info; -- STEP CONTROL (PREDICTOR)
560: when 9 | 10 => Min_Step_Size_Info;
561: when 11 | 12 => Max_Step_Size_Info;
562: when 13 | 14 => Reduction_Factor_Info;
563: when 15 | 16 => Expansion_Factor_Info;
564: when 17 | 18 => Expansion_Threshold_Info;
565: when 19 | 20 => Number_of_Iterations_Info; -- PATH CLOSENESS (CORRECTOR)
566: when 21 | 22 => Relative_Residual_Info;
567: when 23 | 24 => Absolute_Residual_Info;
568: when 25 | 26 => Relative_correction_Info;
569: when 27 | 28 => Absolute_Correction_Info;
570: when 29 | 30 => Singular_Info; -- SOLUTIONS (TOLERANCES)
571: when 31 | 32 => Clustered_Info;
572: when 33 | 34 => Infinity_Info;
573: when others => Exit_Info;
574: end case;
575: new_line;
576: if k /= 0
577: then put("Do you want to change the value of this parameter ? (y/n) ");
578: Ask_Yes_or_No(ans);
579: if ans = 'y'
580: then new_line;
581: get_parameter(k);
582: end if;
583: end if;
584: end get_parameter_with_info;
585:
586: procedure get ( k : out natural ) is
587:
588: tmp : string(1..10);
589: cnt : natural;
590: ans : character;
591: nb : integer := -1;
592: valid,info : boolean;
593:
594: begin
595: loop
596: put("Type a number to change (0 to exit), preceded by i for info : ");
597: get_line(tmp,cnt);
598: valid := true; info := false;
599: for i in 1..cnt loop
600: if tmp(i) = 'i'
601: then info := true;
602: elsif tmp(i) /= ' '
603: and then Characters_and_Numbers.Convert(tmp(i)) = 10
604: then valid := false;
605: end if;
606: exit when not valid;
607: end loop;
608: if not valid
609: then put_line("Invalid answer. Please try again.");
610: else nb := Characters_and_Numbers.Convert(tmp(1..cnt));
611: if nb < 0
612: then put_line("No natural number. Please try again.");
613: put("The current string is :"); put_line(tmp(1..cnt));
614: end if;
615: end if;
616: exit when (nb >= 0);
617: end loop;
618: if info
619: then get_parameter_with_info(nb);
620: if nb = 0
621: then put("Do you want to leave this menu ? (y/n) ");
622: Ask_Yes_or_No(ans);
623: if ans = 'n'
624: then nb := 1;
625: end if;
626: end if;
627: else get_parameter(nb);
628: end if;
629: k := nb;
630: end get;
631:
632: end Continuation_Parameters_io;
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to continuation_parameters_io.adb CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / PHC / Ada / Continuation