source: trunk/ADOL-C/examples/additional_examples/sparse/jacpatexam.cpp @ 171

Last change on this file since 171 was 171, checked in by kulshres, 9 years ago

Squashed merge branch 'master' of 'gitclone' into svn

  • 'master' of 'gitclone': (84 commits) adjust example makefiles and include paths get rid of the symlink in the src subdirectory

details of the commits:
commit c9e4bc332d2363f737fc2e8a8fcfc2e43ddb9d15
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Oct 4 15:43:47 2010 +0200

adjust example makefiles and include paths

include paths in example sources were wrong for some time now
simplify makefile rules too, there is really no need for checking SPARSE
adjust include paths in makefiles.

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

commit e6e1963e41e097fd5b4a79cd1611c12f6868dc94
Author: Kshitij Kulshreshtha <kshitij@…>
Date: Mon Oct 4 15:41:25 2010 +0200

get rid of the symlink in the src subdirectory

windows doesn't like symlinks and make infinite depth directories
we now create a symlink for build in the directory parallel to src
adjust all makefiles.am accordingly for build

Signed-off-by: Kshitij Kulshreshtha <kshitij@…>

  • Property svn:keywords set to Author Date Id Revision
File size: 19.9 KB
Line 
1/*----------------------------------------------------------------------------
2 ADOL-C -- Automatic Differentiation by Overloading in C++
3 File:     jacpatexam.cpp
4 Revision: $Id: jacpatexam.cpp 171 2010-10-04 13:57:19Z kulshres $
5 Contents: example for computation of jacobian sparsity pattern
6
7 Copyright (c) Andrea Walther, Andreas Griewank, Andreas Kowarz,
8               Hristo Mitev, Sebastian Schlenkrich, Jean Utke, Olaf Vogel
9 
10 This file is part of ADOL-C. This software is provided as open source.
11 Any use, reproduction, or distribution of the software constitutes
12 recipient's acceptance of the terms of the accompanying license file.
13 
14---------------------------------------------------------------------------*/
15
16/****************************************************************************/
17/*                                                                 INCLUDES */
18#include <adolc/adolc.h>
19#include <adolc/adolc_sparse.h>
20#include "../clock/myclock.h"
21
22#include <string.h>
23#include <math.h>
24
25#include <iostream>
26using namespace std;
27
28/****************************************************************************/
29/*                                                                  DEFINES */
30
31#define TAG 11
32
33
34/****************************************************************************/
35/*                                                     EVALUATION FUNCTIONS */
36
37/*--------------------------------------------------------------------------*/
38const unsigned int N = 5, M = 6;
39
40void eval_small(short tag, double *xp, double *yp) {
41    unsigned int i,j;
42
43    trace_on(tag);
44
45    adouble *x,*y;
46    x = new adouble[N];
47    y = new adouble[M];
48    for (i=0;i<N;i++)
49        x[i] <<= xp[i];
50
51    int PD1B = __LINE__;
52
53    y[0] = pow(x[0],1) + pow(x[1],2) + pow(x[2],3);
54    y[1] = x[0]        * x[1]        / x[2];
55    y[2] =                                          asin(x[3]*0.1);
56    y[3] = sqrt(x[0])  + sqrt(x[1])  + sqrt(x[2]) + sqrt(x[3])      + sqrt(x[4]);
57    y[4] =                                          log(x[3])       + exp(x[4]);
58    y[5] =                                          cos(x[3])       - sin(x[4]);
59
60    int PD1E = __LINE__;
61
62    for (j=0;j<M;j++)
63        y[j] >>= yp[j];
64
65    delete []x;
66    delete []y;
67
68    trace_off(1); // force a numbered tape file to be written
69
70    cout << "\nproblem definition in  "<<__FILE__<<",  lines  "<<PD1B<<" - "<<PD1E<<"\n";
71}
72
73
74/*--------------------------------------------------------------------------*/
75const unsigned int NM = 961; // PQ_STRIPMINE_MAX * 8*sizeof(unsigned long int) + 1
76
77void eval_arrow_like_matrix(short tag, double *xp, double *yp) {
78    unsigned int i,j;
79
80    trace_on(tag);
81
82    adouble *x,*y;
83    x = new adouble[NM];
84    y = new adouble[NM];
85    for (i=0;i<NM;i++)
86        x[i] <<= xp[i];
87
88    int PD2B = __LINE__;
89
90    for (i=0;i<NM;i++) {
91        /* dense diagonal and dense last column*/
92        y[i] = cos(x[i]) + sin(x[NM-1]);
93    }
94    for (i=0;i<NM;i++)
95        /* dense last row */
96        y[NM-1] += sin(x[i]);
97
98    int PD2E = __LINE__;
99
100    for (j=0;j<NM;j++)
101        y[j] >>= yp[j];
102
103    delete []x;
104    delete []y;
105
106    trace_off(1); // force a numbered tape file to be written
107
108    cout << "\nproblem definition in  "<<__FILE__<<",  lines  "<<PD2B<<" - "<<PD2E<<"\n";
109}
110
111
112/****************************************************************************/
113/*                                                             MAIN PROGRAM */
114int main(void) {
115    short  tag;
116    int    ret_c = -1, choice;
117    int    oper, op_buf_size, loc_buf_size, con_buf_size, maxlive, deaths;
118    unsigned int depen, indep;
119    int    tape_stats[STAT_SIZE];
120    unsigned int    i, j, minnz, maxnz, nz, nzref, nz_rel;
121    double z1, z2, t0, t1, t2, t3, t4, t5, t6=0.0, t7=0.0;
122    char   outp, full_jac;
123    int    precision, width;
124
125    /*--------------------------------------------------------------------------*/
126    /*                    variables needed for the Jacobian pattern exploration */
127
128    unsigned int  **jacpat=NULL; // compressed row storage
129    double        *base, *value;
130    double        basepoint ;
131    int           ctrl[3];
132
133    cout << "----------------------------------------------------------------\n";
134    cout << "\n                Jacobian Pattern Example\n\n";
135    cout << "Tape identification tag ( [-4..-1] for standart examples ) :  ?\b" ;
136    cin  >> choice ;
137
138    cout << "\n\nOutput Jacobian pattern? (y/n)  ?\b";
139    cin >> outp;
140
141    cout << "\n\nCompare with the full Jacobian calculation? (y/n)  ?\b";
142    cin >> full_jac;
143    if (( full_jac == 'y' ) || ( full_jac == 'Y'))
144        full_jac = 1;
145    else
146        full_jac = 0;
147
148    cout << "----------------------------------------------------------------\n";
149
150    /*--------------------------------------------------------------------------*/
151
152
153    if ( choice < 0 ) // Take function in the "eval(...)" routines -------------
154    {
155        if ( choice > -4 ) {
156            base = new double[N];
157            for (i=0;i<N;i++)
158                base[i] = i+1;
159
160            value = new double[M];
161
162            tag = TAG;
163            eval_small(tag, base, value);
164
165            cout << "\n\nCreated ADOL-C tape with identification tag " << tag << ".\n\n";
166            cout.flush();
167
168
169        } else // ( choice == -4 ) -----------------------------------------------
170        {
171
172            base = new double[NM];
173            for (i=0;i<NM;i++)
174                base[i] = i;
175
176            value = new double[NM];
177
178            tag = TAG;
179            eval_arrow_like_matrix(tag, base, value);
180
181            cout << "\n\nCreated ADOL-C tape with identification tag " << tag << ".\n\n";
182            cout.flush();
183
184        }
185
186        tapestats(tag,tape_stats);              /* Reading of tape statistics */
187        indep        = tape_stats[NUM_INDEPENDENTS];
188        depen        = tape_stats[NUM_DEPENDENTS];
189        op_buf_size  = tape_stats[OP_BUFFER_SIZE];
190        loc_buf_size = tape_stats[OP_BUFFER_SIZE];
191        con_buf_size = tape_stats[OP_BUFFER_SIZE];
192        oper         = tape_stats[NUM_OPERATIONS];
193        deaths       = tape_stats[TAY_STACK_SIZE];
194        maxlive      = tape_stats[NUM_MAX_LIVES];
195
196        cout<<"\nTape " << tag << ": \n";
197        cout<<"  independents              "<<indep<<"\n";
198        cout<<"  dependents                "<<depen<<"\n";
199        cout<<"  operations                "<<oper<<"\n";
200        cout<<"  operations buffer size    "<<op_buf_size<<"\n";
201        cout<<"  locations buffer size     "<<loc_buf_size<<"\n";
202        cout<<"  constants buffer size     "<<con_buf_size<<"\n";
203        cout<<"  maxlive                   "<<maxlive<<"\n";
204        cout<<"  valstack size             "<<deaths<<"\n";
205        cout<<"\n";
206
207    } else // ( choice >= 0 ) : Take a written tape ------------------------------
208    {
209        tag = choice;
210
211        cout << "\nproblem definition in  tape "<<tag<<"\n";
212
213        tapestats(tag,tape_stats);
214        indep        = tape_stats[NUM_INDEPENDENTS];
215        depen        = tape_stats[NUM_DEPENDENTS];
216        op_buf_size  = tape_stats[OP_BUFFER_SIZE];
217        loc_buf_size = tape_stats[OP_BUFFER_SIZE];
218        con_buf_size = tape_stats[OP_BUFFER_SIZE];
219        oper         = tape_stats[NUM_OPERATIONS];
220        deaths       = tape_stats[TAY_STACK_SIZE];
221        maxlive      = tape_stats[NUM_MAX_LIVES];
222
223        cout<<"\nTape " << tag << ": \n";
224        cout<<"  independents              "<<indep<<"\n";
225        cout<<"  dependents                "<<depen<<"\n";
226        cout<<"  operations                "<<oper<<"\n";
227        cout<<"  operations buffer size    "<<op_buf_size<<"\n";
228        cout<<"  locations buffer size     "<<loc_buf_size<<"\n";
229        cout<<"  constants buffer size     "<<con_buf_size<<"\n";
230        cout<<"  maxlive                   "<<maxlive<<"\n";
231        cout<<"  valstack size             "<<deaths<<"\n";
232
233        cout << "\n\nbasepoint[0.."<< indep <<"] = ?\b";
234        cin  >> basepoint;
235
236        base  = new double[indep];
237        value = new double[depen];
238
239        for (i=0;i<indep;i++)
240            base[i] = basepoint;
241    }
242
243    tape_doc(tag,depen,indep,base,value); // write a tape into a tex-file
244
245
246    /*--------------------------------------------------------------------------*/
247    /*                                 Jacobian pattern by index domains, safe */
248
249    cout << "\nJacobian Pattern by index domain propagation, safe ...\n";
250
251
252    jacpat = new unsigned int* [depen];
253
254    ctrl[0] = 0; // index domain propagation
255    ctrl[1] = 0; // automatic mode choice (ignored here)
256    ctrl[2] = 0; // safe
257
258    z1 = myclock() ;
259    ret_c = jac_pat( tag, depen, indep,  base, jacpat, ctrl);
260    z2 = myclock() ;
261
262    if (( outp == 'y' ) || ( outp == 'Y')) {
263        for (i=0;i<depen;i++) {
264            cout <<"depen["<< i <<"], "<< jacpat[i][0] <<" non-zero entries :\n";
265            for (j=1;j<=jacpat[i][0];j++)
266                cout << jacpat[i][j] <<"  ";
267            cout <<"\n";
268        }
269        cout.flush();
270    }
271
272    t0 = z2 - z1;
273
274    nz = 0;
275    minnz = indep;
276    maxnz = 0;
277    for (i=0;i<depen;i++) {
278        nz += jacpat[i][0];
279        if ( jacpat[i][0] < minnz )
280            minnz = jacpat[i][0];
281        if ( jacpat[i][0] > maxnz )
282            maxnz = jacpat[i][0];
283    }
284    nz_rel = (int) ceil (100*nz / ((double)depen*indep));
285    cout << nz << " non-zero Jacobian elements  of total " << depen*indep << " elements <= " << nz_rel << "%\n";
286    cout << "min " << minnz << " non-zeros per row;    max " << maxnz << " non-zeros per row;\n";
287    nzref = nz;
288
289    for (i=0;i<depen;i++)
290        myfree1_uint(jacpat[i]);
291    delete[] jacpat;
292    jacpat=NULL;
293
294
295    /*--------------------------------------------------------------------------*/
296    /*                                 Jacobian pattern by index domains, tight */
297
298    cout << "\nJacobian Pattern by index domain propagation, tight ...\n";
299
300    jacpat = new unsigned int* [depen];
301
302    ctrl[0] = 0; // index domain propagation
303    ctrl[1] = 1; // forward (ignored here)
304    ctrl[2] = 1; // tight
305
306    z1 = myclock() ;
307    ret_c = jac_pat( tag, depen, indep,  base, jacpat, ctrl);
308    z2 = myclock() ;
309
310    if (( outp == 'y' ) || ( outp == 'Y')) {
311        for (i=0;i<depen;i++) {
312            cout <<"depen["<< i <<"], "<< jacpat[i][0] <<" non-zero entries :\n";
313            for (j=1;j<=jacpat[i][0];j++)
314                cout << jacpat[i][j] <<"  ";
315            cout <<"\n";
316        }
317        cout.flush();
318    }
319
320    t1 = z2 - z1;
321
322    nz = 0;
323    minnz = indep;
324    maxnz = 0;
325    for (i=0;i<depen;i++) {
326        nz += jacpat[i][0];
327        if ( jacpat[i][0] < minnz )
328            minnz = jacpat[i][0];
329        if ( jacpat[i][0] > maxnz )
330            maxnz = jacpat[i][0];
331    }
332    nz_rel = (int) ceil (100*nz / ((double)depen*indep));
333    cout << nz << " non-zero Jacobian elements of total " << depen*indep << " elements <= " << nz_rel << "%\n";
334    cout << "min " << minnz << " non-zeros per row;    max " << maxnz << " non-zeros per row;\n";
335    if ( nz != nzref )
336        cout << "\n\n!!! This method found a different number of non-zeros !!!\n\n";
337    cout << "\n\n\n";
338
339    for (i=0;i<depen;i++)
340        myfree1_uint(jacpat[i]);
341    delete[] jacpat;
342    jacpat=NULL;
343
344    /*--------------------------------------------------------------------------*/
345    /*                          Jacobian pattern by bit pattern, forward, tight */
346
347    cout << "\nJacobian Pattern by bit pattern propagation, forward, tight ...\n";
348
349    jacpat = new unsigned int* [depen];
350
351    ctrl[0] = 1; // bit pattern propagation
352    ctrl[0] = 1; // forward
353    ctrl[1] = 1; // tight
354
355    z1 = myclock() ;
356    ret_c = jac_pat( tag, depen, indep,  base, jacpat, ctrl);
357    z2 = myclock() ;
358
359    if (( outp == 'y' ) || ( outp == 'Y')) {
360        for (i=0;i<depen;i++) {
361            cout <<"depen["<< i <<"], "<< jacpat[i][0] <<" non-zero entries :\n";
362            for (j=1;j<=jacpat[i][0];j++)
363                cout << jacpat[i][j] <<"  ";
364            cout <<"\n";
365        }
366        cout.flush();
367    }
368
369    t2 = z2 - z1;
370
371    nz = 0;
372    minnz = indep;
373    maxnz = 0;
374    for (i=0;i<depen;i++) {
375        nz += jacpat[i][0];
376        if ( jacpat[i][0] < minnz )
377            minnz = jacpat[i][0];
378        if ( jacpat[i][0] > maxnz )
379            maxnz = jacpat[i][0];
380    }
381    nz_rel = (int) ceil (100*nz / ((double)depen*indep));
382    cout << nz << " non-zero Jacobian elements of total " << depen*indep << " elements <= " << nz_rel << "%\n";
383    cout << "min " << minnz << " non-zeros per row;    max " << maxnz << " non-zeros per row;\n";
384    if ( nz != nzref )
385        cout << "\n\n!!! This method found a different number of non-zeros !!!\n\n";
386
387    for (i=0;i<depen;i++)
388        myfree1_uint(jacpat[i]);
389    delete[] jacpat;
390    jacpat=NULL;
391
392
393    /*--------------------------------------------------------------------------*/
394    /*                           Jacobian pattern by bit pattern, forward, safe */
395
396    cout << "\nJacobian Pattern by bit pattern propagation, forward, safe ...\n";
397
398    jacpat = new unsigned int* [depen];
399
400    ctrl[0] = 1; // bit pattern propagation
401    ctrl[1] = 1; // forward
402    ctrl[2] = 0; // safe
403
404    z1 = myclock() ;
405    ret_c = jac_pat( tag, depen, indep,  base, jacpat, ctrl);
406    z2 = myclock() ;
407
408    if (( outp == 'y' ) || ( outp == 'Y')) {
409        for (i=0;i<depen;i++) {
410            cout <<"depen["<< i <<"], "<< jacpat[i][0] <<" non-zero entries :\n";
411            for (j=1;j<=jacpat[i][0];j++)
412                cout << jacpat[i][j] <<"  ";
413            cout <<"\n";
414        }
415        cout.flush();
416    }
417
418    t3 = z2 - z1;
419
420    nz = 0;
421    minnz = indep;
422    maxnz = 0;
423    for (i=0;i<depen;i++) {
424        nz += jacpat[i][0];
425        if ( jacpat[i][0] < minnz )
426            minnz = jacpat[i][0];
427        if ( jacpat[i][0] > maxnz )
428            maxnz = jacpat[i][0];
429    }
430    nz_rel = (int) ceil (100*nz / ((double)depen*indep));
431    cout << nz << " non-zero Jacobian elements of total " << depen*indep << " elements <= " << nz_rel << "%\n";
432    cout << "min " << minnz << " non-zeros per row;    max " << maxnz << " non-zeros per row;\n";
433    if ( nz != nzref )
434        cout << "\n\n!!! This method found a different number of non-zeros !!!\n\n";
435    cout << "\n\n\n";
436
437    for (i=0;i<depen;i++)
438        myfree1_uint(jacpat[i]);
439    delete[] jacpat;
440    jacpat=NULL;
441
442    /*--------------------------------------------------------------------------*/
443    /*                          Jacobian pattern by bit pattern, reverse, tight */
444
445    cout << "\nJacobian Pattern by bit pattern propagation, reverse, tight ...\n";
446
447    jacpat = new unsigned int* [depen];
448
449    ctrl[0] = 1; // bit pattern propagation
450    ctrl[1] = 2; // reverse
451    ctrl[2] = 1; // tight
452
453    z1 = myclock() ;
454    ret_c = jac_pat( tag, depen, indep,  base, jacpat, ctrl);
455    z2 = myclock() ;
456
457    if (( outp == 'y' ) || ( outp == 'Y')) {
458        for (i=0;i<depen;i++) {
459            cout <<"depen.["<< i <<"], "<< jacpat[i][0] <<" non-zero entries :\n";
460            for (j=1;j<=jacpat[i][0];j++)
461                cout << jacpat[i][j] <<"  ";
462            cout <<"\n";
463        }
464        cout.flush();
465    }
466
467    t4 = z2 - z1;
468
469    nz = 0;
470    minnz = indep;
471    maxnz = 0;
472    for (i=0;i<depen;i++) {
473        nz += jacpat[i][0];
474        if ( jacpat[i][0] < minnz )
475            minnz = jacpat[i][0];
476        if ( jacpat[i][0] > maxnz )
477            maxnz = jacpat[i][0];
478    }
479    nz_rel = (int) ceil (100*nz / ((double)depen*indep));
480    cout << nz << " non-zero Jacobian elements of total " << depen*indep << " elements <= " << nz_rel << "%\n";
481    cout << "min " << minnz << " non-zeros per row;    max " << maxnz << " non-zeros per row;\n";
482    if ( nz != nzref )
483        cout << "\n\n!!! This method found a different number of non-zeros !!!\n\n";
484
485    for (i=0;i<depen;i++)
486        myfree1_uint(jacpat[i]);
487    delete[] jacpat;
488    jacpat=NULL;
489
490
491    /*--------------------------------------------------------------------------*/
492    /*                           Jacobian pattern by bit pattern, reverse, safe */
493
494    cout << "\nJacobian Pattern by bit pattern propagation, reverse, safe ...\n";
495
496    jacpat = new unsigned int* [depen];
497
498    ctrl[0] = 1; // bit pattern propagation
499    ctrl[1] = 2; // reverse
500    ctrl[2] = 0; // safe
501
502    z1 = myclock() ;
503    ret_c = jac_pat( tag, depen, indep,  base, jacpat, ctrl);
504    z2 = myclock() ;
505
506    if (( outp == 'y' ) || ( outp == 'Y')) {
507        for (i=0;i<depen;i++) {
508            cout <<"depen.["<< i <<"], "<< jacpat[i][0] <<" non-zero entries :\n";
509            for (j=1;j<=jacpat[i][0];j++)
510                cout << jacpat[i][j] <<"  ";
511            cout <<"\n";
512        }
513        cout.flush();
514    }
515
516    t5 = z2 - z1;
517
518    nz = 0;
519    minnz = indep;
520    maxnz = 0;
521    for (i=0;i<depen;i++) {
522        nz += jacpat[i][0];
523        if ( jacpat[i][0] < minnz )
524            minnz = jacpat[i][0];
525        if ( jacpat[i][0] > maxnz )
526            maxnz = jacpat[i][0];
527    }
528    nz_rel = (int) ceil (100*nz / ((double)depen*indep));
529    cout << nz << " non-zero Jacobian elements of total " << depen*indep << " elements  <= " << nz_rel << "%\n";
530    cout << "min " << minnz << " non-zeros per row;    max " << maxnz << " non-zeros per row;\n";
531    if ( nz != nzref )
532        cout << "\n\n!!! This method found a different number of non-zeros !!!\n\n";
533    cout << "\n\n\n";
534
535    for (i=0;i<depen;i++)
536        myfree1_uint(jacpat[i]);
537    delete[] jacpat;
538    jacpat=NULL;
539
540
541    /* full Jacobian evaluation -----------------------------------------------*/
542
543    if ( full_jac ) {
544        /*---------------------------------------------------------------------*/
545        /*                        variables needed for the evaluation routines */
546
547        double **Jac = new double*[depen];
548        for (i=0;i<depen;i++)
549            Jac[i] = new double[indep];
550        double **I = new double*[indep];
551        for (i=0;i<indep;i++) {
552            I[i] = new double[indep];
553            for (j=0;j<indep;j++)
554                I[i][j] = 0.0;
555            I[i][i] = 1.0;
556        }
557
558
559        /*---------------------------------------------------------------------*/
560        /*                full Jacobian evaluation by forward, no strip-mining */
561
562        cout << "\nFull Jacobian evaluation by forward(..), no \"strip-mining\" ...\n";
563
564        z1 = myclock() ;
565
566        forward( tag, depen, indep, indep, base, I, value, Jac);
567
568        z2 = myclock() ;
569
570        t6 = z2 - z1;
571
572
573        /*---------------------------------------------------------------------*/
574        /*    full Jacobian evaluation by the jacobian driver, no strip-mining */
575
576        cout << "\nFull Jacobian evaluation by the jacobian driver, no \"strip-mining\" ...\n";
577
578        z1 = myclock() ;
579
580        jacobian( tag, depen, indep, base, Jac);
581
582        z2 = myclock() ;
583
584        t7 = z2 - z1;
585
586    }
587
588
589    /*--------------------------------------------------------------------------*/
590    /* output of timings */
591    width = 8;
592    precision = 2;
593
594    cout.setf(ios::fixed,ios::floatfield);
595    cout.setf(ios::right,ios::adjustfield);
596    cout.precision(precision);
597
598    cout << "\n\n----------------------------------------------------------------\n";
599    cout << "\n\nTime to explore the Jacobian Pattern by :\n\n";
600    cout << " index domain propagation, safe          :  ";
601    cout.width(width);
602    cout << t0 << " sec.\n";
603    cout << " index domain propagation, tight         :  ";
604    cout.width(width);
605    cout << t1 << " sec.\n";
606    cout << " bit pattern propagation, forward, tight :  ";
607    cout.width(width);
608    cout << t2 << " sec.\n";
609    cout << " index domain propagation, forward, safe :  ";
610    cout.width(width);
611    cout << t3 << " sec.\n";
612    cout << " bit pattern propagation, reverse, tight :  ";
613    cout.width(width);
614    cout << t4 << " sec.\n";
615    cout << " bit pattern propagation, reverse, safe  :  ";
616    cout.width(width);
617    cout << t5 << " sec.\n\n";
618    if ( full_jac ) {
619        cout << " full Jacobian evaluation, forward   :  ";
620        cout.width(width);
621        cout << t6 << " sec.\n";
622        cout << " full Jacobian evaluation, jacobian  :  ";
623        cout.width(width);
624        cout << t7 << " sec.\n";
625    }
626
627    if ( ! ( t0 && t1 && t2 && t3 && t4  && t5 ) )
628        cout <<"\n! Zero timing due to low problem dimension.\n";
629
630    cout <<"\nOK, done.\n";
631    cout.flush();
632
633    return 1;
634}
Note: See TracBrowser for help on using the repository browser.