00001 #include "gfunct.h"
00002 #include "tablefunct.h"
00003 #include "itablefunct.h"
00004 #include "intools.h"
00005 #include "vector.h"
00006 #include <string.h>
00007
00008
00009
00010
00011
00012
00013 gfunct::gfunct()
00014 {
00015
00016 neqs = 0L;
00017
00018 ngf = 0L;
00019
00020 f = 0.0;
00021 tfunc=stat;
00022 eq = NULL;
00023 var = NULL;
00024 func = NULL;
00025 limval = NULL;
00026 tabf = NULL;
00027 itabf = NULL;
00028 gfs = NULL;
00029 }
00030
00031
00032
00033
00034
00035
00036
00037 gfunct::gfunct(generalfunct tf,long nr)
00038 {
00039
00040 neqs = 0L;
00041
00042 ngf = 0L;
00043
00044 f = 0.0;
00045
00046 tfunc=tf;
00047
00048 eq = NULL;
00049 var = NULL;
00050 func = NULL;
00051 limval = NULL;
00052 itabf = NULL;
00053 gfs = NULL;
00054
00055 switch (tfunc){
00056 case stat:{
00057
00058 break;
00059 }
00060 case tab_file:
00061 case tab:{
00062 tabf = new tablefunct (nr);
00063 break;
00064 }
00065 default:{
00066 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00067 }
00068 }
00069 }
00070
00071
00072
00073
00074
00075
00076 gfunct::~gfunct()
00077 {
00078 long i;
00079 for (i = 0; i < neqs; i++){
00080 delete [] func[i];
00081 delete [] var[i];
00082 delete eq[i];
00083 }
00084 delete [] func;
00085 delete [] eq;
00086 delete [] var;
00087 delete [] gfs;
00088 delete tabf;
00089 delete itabf;
00090 delete [] gfs;
00091 }
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111 long gfunct::read(XFILE *in)
00112 {
00113 long i, j;
00114 Parser par;
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124 xfscanf (in,"%k%m","funct_type", &generalfunct_kwdset, (int*)&tfunc);
00125
00126 switch (tfunc){
00127 case stat:{
00128 xfscanf (in,"%k%lf","const_val", &f);
00129 break;
00130 }
00131 case pars:{
00132 neqs = 1;
00133 eq = new Equation* [neqs];
00134 var = new variable**[neqs];
00135 func = new char* [neqs];
00136 for (i = 0; i < neqs; i++)
00137 {
00138 func[i]=new char [256];
00139 xfscanf(in, "%k%255s", "func_formula", func[i]);
00140
00141 eq[i] = par.TextToTree(func[i]);
00142 if (eq[i] == NULL)
00143 {
00144 print_err("Error parsing expression",__FILE__,__LINE__,__func__);
00145 return (1);
00146 }
00147 var[i] = NULL;
00148 if (eq[i]->Variables.count())
00149 var[i] = new variable* [eq[i]->Variables.count()];
00150 for(j=0; j < eq[i]->Variables.count(); j++)
00151 var[i][j] = eq[i]->Variables.at(j);
00152 }
00153 break;
00154 }
00155 case tab:{
00156 tabf = new tablefunct;
00157 tabf->read(in);
00158 break;
00159 }
00160 case tab_file:{
00161 tabf = new tablefunct;
00162 tabf->read_data_file(in);
00163 break;
00164 }
00165 case pars_set:{
00166 xfscanf (in, "%k%ld", "num_funct", &neqs);
00167 if (neqs <= 0)
00168 {
00169 print_err("Number of expressions in set <= 0",__FILE__,__LINE__,__func__);
00170 return (2);
00171 }
00172 eq = new Equation* [neqs];
00173 var = new variable**[neqs];
00174 func = new char* [neqs];
00175 limval = new double [neqs];
00176 for (i = 0; i < neqs; i++)
00177 {
00178 xfscanf(in, "%k%le", "limval", limval+i);
00179 func[i]=new char [256];
00180 xfscanf(in, "%k%255s", "func_formula", func[i]);
00181 eq[i] = par.TextToTree(func[i]);
00182 if (eq[i] == NULL)
00183 {
00184 print_err("parsing expression", __FILE__, __LINE__, __func__);
00185 return (3);
00186 }
00187 var[i] = NULL;
00188 if (eq[i]->Variables.count())
00189 var[i] = new variable* [eq[i]->Variables.count()];
00190 for(j=0; j < eq[i]->Variables.count(); j++)
00191 var[i][j] = eq[i]->Variables.at(j);
00192 }
00193 break;
00194 }
00195 case itab:{
00196 itabf = new itablefunct;
00197 itabf->read(in);
00198 break;
00199 }
00200 case gfunc_set:{
00201 xfscanf (in, "%k%ld", "num_funct", &ngf);
00202 if (ngf <= 0)
00203 {
00204 print_err("Number of functions in set <= 0",__FILE__,__LINE__,__func__);
00205 return (4);
00206 }
00207 gfs = new gfunct[ngf];
00208 for (i = 0; i < ngf; i++)
00209 {
00210 gfs[i].read(in);
00211 }
00212 break;
00213 }
00214 default:{
00215 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00216 return (5);
00217 }
00218 }
00219 return(0);
00220 }
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234 double gfunct::getval(double t)
00235 {
00236 long i;
00237 double ret = 0.0;
00238
00239 switch (tfunc)
00240 {
00241 case stat:
00242 ret=f;
00243 break;
00244 case pars:
00245 if (var[0])
00246 var[0][0]->Value = t;
00247 ret = eq[0]->Evaluate();
00248 break;
00249 case tab_file:
00250 case tab:
00251 ret=tabf[0].getval(t);
00252 break;
00253 case pars_set:
00254 {
00255 for (i = 0; i < neqs; i++)
00256 {
00257 if (limval[i] >= t)
00258 {
00259 if (var[i])
00260 var[i][0]->Value = t;
00261 ret = eq[i]->Evaluate();
00262 break;
00263 }
00264 if (i == neqs-1)
00265 {
00266 if (var[i])
00267 var[i][0]->Value = t;
00268 ret = eq[i]->Evaluate();
00269 }
00270 }
00271 break;
00272 }
00273 case gfunc_set:
00274 {
00275 for (i = 0; i < ngf; i++)
00276 {
00277 ret += gfs[i].getval(t);
00278 }
00279 break;
00280 }
00281 default:
00282 {
00283 print_err("unknown type of general function is required - %d, this=%p", __FILE__, __LINE__, __func__, tfunc, this);
00284 }
00285 }
00286
00287 return(ret);
00288 }
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298
00299
00300 double gfunct::getinvval(double t)
00301 {
00302 double ret = 0.0;
00303
00304 switch (tfunc){
00305 case tab:{
00306 ret=tabf[0].getinvval(t);
00307 break;
00308 }
00309 default:{
00310 print_err("unknown type of general function is required - %d, this=%p", __FILE__, __LINE__, __func__, tfunc, this);
00311 }
00312 }
00313
00314 return(ret);
00315 }
00316
00317
00318
00319
00320
00321
00322
00323
00324
00325
00326
00327
00328
00329
00330
00331 double gfunct::getval(vector &p, char *namevar[])
00332 {
00333 long i, j;
00334 double ret = 0.0;
00335
00336 if (p.n == 1)
00337 {
00338 ret = getval(p(0));
00339 return ret;
00340 }
00341 switch (tfunc)
00342 {
00343 case stat:
00344 ret = f;
00345 break;
00346 case pars:
00347 for(i=0; i<p.n; i++)
00348 {
00349 for (j=0; j < eq[0]->Variables.count(); j++)
00350 {
00351 if (strcmp(namevar[i], var[0][j]->Name) == 0)
00352 {
00353 var[0][j]->Value = p(i);
00354 break;
00355 }
00356 }
00357 }
00358
00359 ret = eq[0]->Evaluate();
00360 break;
00361 default:
00362 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00363 }
00364
00365 return ret;
00366 }
00367
00368
00369
00370
00371
00372
00373
00374
00375
00376
00377
00378
00379
00380
00381 double gfunct::getval(double t, double t0)
00382 {
00383 long i;
00384 double ret = 0.0;
00385
00386
00387 switch (tfunc)
00388 {
00389 case stat:
00390 ret=f;
00391 break;
00392 case pars:
00393 if (eq[0]->Variables.count() < 2)
00394 {
00395 getval(t);
00396 break;
00397 }
00398 if (var[0])
00399 {
00400 var[0][0]->Value = t;
00401 if (var[0][1])
00402 var[0][1]->Value = t0;
00403 }
00404 ret = eq[0]->Evaluate();
00405 break;
00406 case tab_file:
00407 case tab:
00408 ret=tabf[0].getval(t);
00409 break;
00410 case pars_set:
00411 {
00412 for (i = 0; i < neqs; i++)
00413 {
00414 if (limval[i] >= t)
00415 {
00416 if (eq[i]->Variables.count() < 2)
00417 {
00418 getval(t);
00419 break;
00420 }
00421 if (var[i])
00422 {
00423 var[i][0]->Value = t;
00424 if (var[i][1])
00425 var[i][1]->Value = t0;
00426 }
00427 ret = eq[i]->Evaluate();
00428 break;
00429 }
00430 if (i == neqs-1)
00431 {
00432 if (eq[i]->Variables.count() < 2)
00433 {
00434 getval(t);
00435 break;
00436 }
00437 if (var[i])
00438 {
00439 var[i][0]->Value = t;
00440 if (var[i][1])
00441 var[i][1]->Value = t;
00442 }
00443 ret = eq[i]->Evaluate();
00444 }
00445 }
00446 break;
00447 }
00448 case gfunc_set:
00449 {
00450 for (i = 0; i < ngf; i++)
00451 {
00452 ret += gfs[i].getval(t,t0);
00453 }
00454 break;
00455 }
00456 default:
00457 {
00458 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00459 }
00460 }
00461
00462 return(ret);
00463 }
00464
00465
00466
00467
00468
00469
00470
00471
00472
00473
00474
00475
00476
00477 long gfunct::getval_long(double t)
00478 {
00479 long i, ret;
00480
00481 switch (tfunc)
00482 {
00483 case itab:{
00484 ret=itabf[0].getval(t);
00485 break;
00486 }
00487 case gfunc_set:
00488 {
00489 ret = 0;
00490 for (i = 0; i < ngf; i++)
00491 {
00492 ret += gfs[i].getval_long(t);
00493 }
00494 break;
00495 }
00496 default:{
00497 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00498 }
00499 }
00500
00501 return(ret);
00502 }
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516 double gfunct::getderiv (double t)
00517 {
00518 double ret = 0.0;
00519
00520 switch (tfunc){
00521 case stat:{
00522 ret=0.0;
00523 break;
00524 }
00525 case tab_file:
00526 case tab:{
00527 ret=tabf[0].getderiv (t);
00528 break;
00529 }
00530 default:{
00531 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00532 }
00533 }
00534
00535 return(ret);
00536 }
00537
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547
00548
00549
00550 double gfunct::getinvderiv (double t)
00551 {
00552 double ret = 0.0;
00553
00554 switch (tfunc){
00555 case stat:{
00556 ret=0.0;
00557 break;
00558 }
00559 case tab_file:
00560 case tab:{
00561 ret=tabf[0].inv_derivative (t);
00562 break;
00563 }
00564 default:{
00565 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00566 }
00567 }
00568
00569 return(ret);
00570 }
00571
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586
00587
00588
00589 long gfunct::read_prop(FILE *in)
00590 {
00591 long i;
00592 Parser par;
00593
00594 getint(in, (int &)tfunc);
00595 switch (tfunc)
00596 {
00597 case stat:
00598 getdouble(in, f);
00599 break;
00600 case pars:
00601 neqs = 1;
00602 eq = new Equation* [neqs];
00603 func = new char* [neqs];
00604 for (i = 0; i < neqs; i++)
00605 {
00606 func[i]=new char [256];
00607 getstring(in, func[i], 255);
00608 eq[i] = par.TextToTree(func[i]);
00609 if (eq[i] == NULL)
00610 {
00611 print_err("Error parsing expression", __FILE__, __LINE__, __func__);
00612 return(1);
00613 }
00614 }
00615 break;
00616 case tab_file:
00617 case tab:
00618 tabf = new tablefunct;
00619 tabf->read_prop(in);
00620 break;
00621 case pars_set:
00622 {
00623 getlong(in, neqs);
00624 if (neqs <= 0)
00625 {
00626 print_err("Number of expressions in set <= 0", __FILE__, __LINE__, __func__);
00627 return (2);
00628 }
00629 eq = new Equation* [neqs];
00630 func = new char* [neqs];
00631 limval = new double [neqs];
00632 for (i = 0; i < neqs; i++)
00633 {
00634 getdouble(in, limval[i]);
00635 func[i]=new char [256];
00636 getstring(in, func[i], 255);
00637 eq[i] = par.TextToTree(func[i]);
00638 if (eq[i] == NULL)
00639 {
00640 print_err("Error parsing expression", __FILE__, __LINE__, __func__);
00641 return(3);
00642 }
00643 }
00644 break;
00645 }
00646 case itab:
00647 itabf = new itablefunct;
00648 itabf->read_prop(in);
00649 case gfunc_set:
00650 {
00651 getlong(in, ngf);
00652 if (ngf <= 0)
00653 {
00654 print_err("Number of functions in set <= 0", __FILE__, __LINE__, __func__);
00655 return (4);
00656 }
00657 for (i = 0; i < ngf; i++)
00658 {
00659 gfs[i].read_prop(in);
00660 }
00661 break;
00662 }
00663 default:
00664 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00665 return(5);
00666 }
00667 return(0);
00668 }
00669
00670
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683 long gfunct::print(FILE *out)
00684 {
00685 Parser par;
00686 long i;
00687
00688 fprintf (out,"\n\n %d ",tfunc);
00689
00690 switch (tfunc){
00691 case stat:{
00692 fprintf (out,"%e\n",f);
00693 break;
00694 }
00695 case pars:{
00696 fprintf(out, " %s\n", func[0]);
00697 break;
00698 }
00699 case tab:{
00700 tabf->print(out);
00701 break;
00702 }
00703 case tab_file:{
00704 tabf->print_data_file(out);
00705 break;
00706 }
00707 case pars_set:{
00708 fprintf (out, "%ld\n", neqs);
00709 for (i=0; i<neqs; i++)
00710 fprintf(out, " %s\n", func[i]);
00711 break;
00712 }
00713 case itab:{
00714 itabf->print(out);
00715 break;
00716 }
00717 case gfunc_set:{
00718 for (i = 0; i < ngf; i++)
00719 {
00720 gfs[i].print(out);
00721 }
00722 break;
00723 }
00724 default:{
00725 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00726 return (1);
00727 }
00728 }
00729 fprintf (out,"\n");
00730
00731 return(0);
00732 }
00733
00734
00735
00736
00737
00738
00739
00740
00741 void gfunct::initiate (gfunct &gf)
00742 {
00743 long i;
00744
00745 tfunc = gf.tfunc;
00746
00747 switch (tfunc){
00748 case stat:{
00749 f=gf.f;
00750 break;
00751 }
00752 case tab_file:
00753 case tab:{
00754 tabf = new tablefunct;
00755 tabf->itype = gf.tabf->itype;
00756 tabf->asize = gf.tabf->asize;
00757 tabf->x=new double[tabf->asize];
00758 tabf->y=new double[tabf->asize];
00759 for (i=0;i<tabf->asize;i++){
00760 tabf->x[i]=gf.tabf->x[i];
00761 tabf->y[i]=gf.tabf->y[i];
00762 }
00763 break;
00764 }
00765 default:{
00766 print_err("unknown type of general function is required", __FILE__, __LINE__, __func__);
00767 }
00768 }
00769 }
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784 void gfunct::init_tab (long nr)
00785 {
00786 tfunc = tab;
00787 tabf = new tablefunct;
00788 tabf->itype = piecewiselin;
00789 tabf->asize = nr;
00790 tabf->x = new double [nr];
00791 tabf->y = new double [nr];
00792 }
00793
00794
00795
00796
00797
00798
00799
00800
00801
00802
00803
00804
00805
00806
00807
00808 void gfunct::copy (gfunct &gf)
00809 {
00810 long i, j;
00811 Parser par;
00812
00813 switch (gf.tfunc)
00814 {
00815 case stat:{
00816
00817 tfunc = gf.tfunc;
00818
00819 neqs = gf.neqs;
00820
00821 ngf = gf.ngf;
00822
00823 f = gf.f;
00824 break;
00825 }
00826 case pars:
00827 case pars_set:{
00828 if (neqs)
00829 {
00830 for (i=0; i<neqs; i++)
00831 {
00832 delete eq[i];
00833 delete [] var[i];
00834 delete [] func[i];
00835 }
00836 delete [] eq;
00837 delete [] var;
00838 delete [] func;
00839 }
00840
00841 tfunc = gf.tfunc;
00842
00843 neqs = gf.neqs;
00844
00845 ngf = gf.ngf;
00846 eq = new Equation* [gf.neqs];
00847 var = new variable**[gf.neqs];
00848 func = new char* [gf.neqs];
00849 for (i = 0; i < gf.neqs; i++)
00850 {
00851 func[i]=new char [256];
00852 strcpy(func[i], gf.func[i]);
00853 eq[i] = par.TextToTree(func[i]);
00854 var[i] = NULL;
00855 if (eq[i]->Variables.count())
00856 var[i] = new variable* [eq[i]->Variables.count()];
00857 for(j=0; j < eq[i]->Variables.count(); j++)
00858 var[i][j] = eq[i]->Variables.at(j);
00859 }
00860 break;
00861 }
00862 case tab_file:
00863 case tab:{
00864
00865 tfunc = gf.tfunc;
00866
00867 neqs = gf.neqs;
00868
00869 ngf = gf.ngf;
00870 if (tabf)
00871 delete tabf;
00872 tabf = new tablefunct;
00873 tabf->copy (gf.tabf[0]);
00874 break;
00875 }
00876 case itab:{
00877
00878 tfunc = gf.tfunc;
00879
00880 neqs = gf.neqs;
00881
00882 ngf = gf.ngf;
00883 if (itabf)
00884 delete itabf;
00885 itabf = new itablefunct;
00886 itabf->copy (gf.itabf[0]);
00887 break;
00888 }
00889 case gfunc_set:
00890 {
00891 if (ngf)
00892 delete [] gfs;
00893
00894 tfunc = gf.tfunc;
00895
00896 neqs = gf.neqs;
00897
00898 ngf = gf.ngf;
00899 for (i = 0; i < gf.ngf; i++)
00900 {
00901 gfs[i].copy(gf.gfs[i]);
00902 }
00903 break;
00904 }
00905 default:{
00906 print_err("unknown type of general function is required",__FILE__,__LINE__,__func__);
00907 }
00908 }
00909 return;
00910 }
00911
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921
00922
00923
00924
00925 void gfunct::merge (gfunct &gf)
00926 {
00927 long i;
00928 gfunct *tmp;
00929
00930 if ((tfunc == gfunc_set) && (gf.tfunc != gfunc_set))
00931 {
00932 tmp = new gfunct[ngf+1];
00933 for(i=0; i<ngf; i++)
00934 tmp[i].copy(gfs[i]);
00935 tmp[ngf].copy(gf);
00936 ngf++;
00937 delete [] gfs;
00938
00939 gfs = tmp;
00940 return;
00941 }
00942 if ((gf.tfunc == gfunc_set) && (tfunc != gfunc_set))
00943 {
00944 for (i = 0; i < neqs; i++){
00945 delete [] func[i];
00946 delete [] var[i];
00947 delete eq[i];
00948 }
00949 delete [] func;
00950 delete [] eq;
00951 delete [] var;
00952 delete [] gfs;
00953 delete tabf;
00954 delete itabf;
00955 gfs = new gfunct[gf.ngf+1];
00956 gfs[0].copy(*this);
00957 for(i=0; i<gf.ngf; i++)
00958 gfs[i+1].copy(gf.gfs[i]);
00959
00960 tfunc = gfunc_set;
00961
00962 ngf = gf.ngf+1;
00963 return;
00964 }
00965 if ((gf.tfunc == gfunc_set) && (tfunc == gfunc_set))
00966 {
00967 tmp = new gfunct[ngf+gf.ngf];
00968 for(i=0; i<ngf; i++)
00969 tmp[i].copy(gfs[i]);
00970 for(i=0; i<gf.ngf; i++)
00971 tmp[i+ngf].copy(gf.gfs[i]);
00972
00973 ngf+=gf.ngf;
00974 delete [] gfs;
00975 gfs = tmp;
00976 return;
00977 }
00978 switch (tfunc){
00979 case stat:
00980 case pars:
00981 case pars_set:
00982 case tab_file:
00983 case tab:
00984 case itab:
00985 gfs = new gfunct[2];
00986 gfs[0].copy(*this);
00987 gfs[1].copy(gf);
00988
00989 tfunc = gfunc_set;
00990
00991 ngf = gf.ngf;
00992 break;
00993 default:{
00994 print_err("unknown type of general function is required",__FILE__,__LINE__,__func__);
00995 }
00996 }
00997 return;
00998 }
00999
01000
01001
01002
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014 long gfunct::compare (gfunct &gf)
01015 {
01016 long i;
01017 Parser par;
01018
01019
01020
01021 if (tfunc != gf.tfunc)
01022 return 1;
01023
01024 switch (gf.tfunc)
01025 {
01026 case stat:{
01027
01028 if (f == gf.f)
01029 return 0;
01030 else
01031 return 1;
01032 }
01033 case pars:
01034
01035 if (neqs != gf.neqs)
01036 return 1;
01037 if (strcmp(func[0], gf.func[0]))
01038 return 1;
01039
01040 return 0;
01041 case pars_set:{
01042
01043 if (neqs != gf.neqs)
01044 return 1;
01045 for (i = 0; i < gf.neqs; i++)
01046 {
01047 if (strcmp(func[i], gf.func[i]))
01048 return 1;
01049 if (limval[i] != gf.limval[i])
01050 return 1;
01051 }
01052
01053 return 0;
01054 }
01055 case tab_file:
01056 case tab:{
01057 return tabf->compare(gf.tabf[0]);
01058 }
01059 case itab:{
01060 return itabf->compare(gf.itabf[0]);
01061 }
01062 case gfunc_set:
01063 {
01064
01065 if (ngf != gf.ngf)
01066 return 1;
01067 for (i = 0; i < gf.ngf; i++)
01068 {
01069 if (gfs[i].compare(gf.gfs[i]))
01070 return 1;
01071 }
01072 return 0;
01073 }
01074 default:{
01075 print_err("unknown type of general function is required",__FILE__,__LINE__,__func__);
01076 }
01077 }
01078 return 1;
01079 }
01080
01081