Actual source code: tvecsingle.c
1: #include "tvecsingle.h"
2: #include "tao_general.h"
3: #include "stdio.h"
5: TaoVecFloatArray::TaoVecFloatArray(int nn):TaoVec(),n(nn){
6: v=new float[nn];
7: fallocated=1;
8: return;
9: }
11: TaoVecFloatArray::TaoVecFloatArray(int nn, float *ff):TaoVec(),n(nn){
12: v=ff;
13: fallocated=0;
14: return;
15: }
17: int TaoVecFloatArray::Clone( TaoVec** tv ){
19: *tv = new TaoVecFloatArray(this->n);
20: int info = (*tv)->CopyFrom(this);CHKERRQ(info);
21: return 0;
22: }
24: int TaoVecFloatArray::GetFloats(float **fptr, int *nn){
25: *fptr=v;
26: *nn=n;
27: return 0;
28: }
30: int TaoVecFloatArray::RestoreFloats(float **fptr, int *nn){
31: *fptr=0;
32: *nn=0;
33: return 0;
34: }
36: int TaoVecFloatArray::GetDimension(int *nn){
37: *nn=n;
38: return 0;
39: }
41: int TaoVecFloatArray::Compatible(TaoVec *tv, TaoTruth *flag){
42: int nn,info;
43: float *fptr;
44: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
46: info = vv->GetData(&fptr,&nn);
47: if (info==0 && nn == n) *flag=TAO_TRUE;
48: else *flag=TAO_FALSE;
49: return 0;
50: }
52: int TaoVecFloatArray::View(){
53: for (int i=0;i<n;++i)
54: printf(" %4.2e \n ",v[i]);
55: return 0;
56: }
61: int TaoVecFloatArray::SetToConstant( double c ){
62: int i,nn,info;
63: float *tptr;
65: TaoFunctionBegin;
66: info = this->GetFloats(&tptr,&nn);CHKERRQ(info);
67: for (i=0;i<nn;i++){ tptr[i]=c; }
68: info = this->RestoreFloats(&tptr,&nn);CHKERRQ(info);
69: TaoFunctionReturn(0);
70: }
74: int TaoVecFloatArray::SetToZero(){
75: int i,nn,info;
76: float *tptr;
78: TaoFunctionBegin;
79: info = this->GetFloats(&tptr,&nn);CHKERRQ(info);
80: for (i=0;i<nn;i++){ tptr[i]=0; }
81: info = this->RestoreFloats(&tptr,&nn);CHKERRQ(info);
82: TaoFunctionReturn(0);
83: }
87: int TaoVecFloatArray::CopyFrom( TaoVec* tv ){
88: int i,nn1,nn2,info;
89: float *tptr1,*tptr2;
90: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
92: TaoFunctionBegin;
93: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
94: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
96: for (i=0;i<nn1;i++){ tptr1[i]=tptr2[i]; }
98: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
99: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
100: TaoFunctionReturn(0);
101: }
105: int TaoVecFloatArray::ScaleCopyFrom( double a, TaoVec* tv ){
106: int i,nn1,nn2,info;
107: float *tptr1,*tptr2;
108: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
110: TaoFunctionBegin;
111: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
112: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
113: for (i=0;i<nn1;i++){ tptr1[i]=a*tptr2[i]; }
114: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
115: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
116: TaoFunctionReturn(0);
117: }
121: int TaoVecFloatArray::NormInfinity(double *vnorm){
122: int i,nn,info;
123: float dd=0, *vv;
125: TaoFunctionBegin;
126: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
127: for (i=0;i<nn;i++){
128: if (vv[i]<0 && vv[i]<-dd) dd=-vv[i];
129: else if (vv[i]>0 && vv[i]>dd) dd=vv[i];
130: }
131: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
132: *vnorm=dd;
133: TaoFunctionReturn(0);
134: }
138: int TaoVecFloatArray::Norm1(double *vnorm){
139: int i,nn,info;
140: float dd=0, *vv;
142: TaoFunctionBegin;
143: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
144: for (i=0;i<nn;i++){
145: if (vv[i]<0) dd-=vv[i];
146: else dd+=vv[i];
147: }
148: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
149: TaoFunctionReturn(0);
150: }
154: int TaoVecFloatArray::Norm2(double *vnorm){
155: int i,nn,info;
156: float dd=0, *vv;
158: TaoFunctionBegin;
159: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
160: for (i=0;i<nn;i++) dd+=vv[i]*vv[i];
161: *vnorm=sqrt(dd);
162: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
163: TaoFunctionReturn(0);
164: }
168: int TaoVecFloatArray::Norm2squared(double *vnorm2){
169: int i,nn,info;
170: float dd=0, *vv;
172: TaoFunctionBegin;
173: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
174: for (i=0;i<nn;i++) dd+=vv[i]*vv[i];
175: *vnorm2=dd;
176: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
177: TaoFunctionReturn(0);
178: }
182: int TaoVecFloatArray::Scale( double alpha ){
183: int i,nn,info;
184: float *vv;
186: TaoFunctionBegin;
187: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
188: for (i=0;i<nn;i++) vv[i]*=alpha;
189: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
190: TaoFunctionReturn(0);
191: }
195: int TaoVecFloatArray::Axpy( double alpha, TaoVec* tv ){
196: int i,nn1,nn2,info;
197: float *tptr1,*tptr2;
198: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tv);
200: TaoFunctionBegin;
201: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
202: info = xx->GetFloats(&tptr2,&nn2);CHKERRQ(info);
203: for (i=0;i<nn1;i++){ tptr1[i]+= alpha * tptr2[i]; }
204: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
205: info = xx->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
206: TaoFunctionReturn(0);
207: }
211: int TaoVecFloatArray::Axpby( double alpha, TaoVec* tv, double beta ){
212: int i,nn1,nn2,info;
213: float *tptr1,*tptr2;
214: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tv);
216: TaoFunctionBegin;
217: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
218: info = xx->GetFloats(&tptr2,&nn2);CHKERRQ(info);
219: for (i=0;i<nn1;i++){ tptr1[i] = beta * tptr1[i] + alpha * tptr2[i]; }
220: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
221: info = xx->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
222: TaoFunctionReturn(0);
223: }
227: int TaoVecFloatArray::Aypx( double alpha, TaoVec* tv ){
228: int i,nn1,nn2,info;
229: float *tptr1,*tptr2;
230: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tv);
232: TaoFunctionBegin;
233: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
234: info = xx->GetFloats(&tptr2,&nn2);CHKERRQ(info);
235: for (i=0;i<nn1;i++){ tptr1[i] = alpha * tptr1[i] + tptr2[i]; }
236: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
237: info = xx->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
238: TaoFunctionReturn(0);
239: }
240:
243: int TaoVecFloatArray::AddConstant( double alpha ){
244: int i,nn,info;
245: float *vv;
247: TaoFunctionBegin;
248: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
249: for (i=0;i<nn;i++) vv[i]+=alpha;
250: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
251: TaoFunctionReturn(0);
252: }
256: int TaoVecFloatArray::Dot( TaoVec* tv, double *vDotv ){
257: int i,nn1,nn2,info;
258: float dd=0,*tptr1,*tptr2;
259: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
261: TaoFunctionBegin;
262: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
263: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
264: for (i=0;i<nn1;i++) dd+=tptr1[i]*tptr2[i];
265: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
266: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
267: *vDotv=dd;
268: TaoFunctionReturn(0);
269: }
273: int TaoVecFloatArray::Negate(){
274: int i,nn,info;
275: float *vv;
277: TaoFunctionBegin;
278: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
279: for (i=0;i<nn;i++) vv[i]=-vv[i];
280: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
281: TaoFunctionReturn(0);
282: }
286: int TaoVecFloatArray::Reciprocal(){
287: int i,nn,info;
288: float *vv;
290: TaoFunctionBegin;
291: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
292: for (i=0;i<nn;i++){
293: if (vv[i]!=0) vv[i]= 1.0/vv[i];
294: else vv[i]=TAO_INFINITY;
295: }
296: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
297: TaoFunctionReturn(0);
298: }
302: int TaoVecFloatArray::Sqrt(){
303: int i,nn,info;
304: float *vv;
306: TaoFunctionBegin;
307: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
308: for (i=0;i<nn;i++){
309: if (vv[i] >= 0) vv[i]= sqrt(vv[i]);
310: else vv[i]=TAO_INFINITY;
311: }
312: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
313: TaoFunctionReturn(0);
314: }
318: int TaoVecFloatArray::Pow(double p){
319: int i,nn,info;
320: float *vv;
322: TaoFunctionBegin;
323: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
324: for (i=0;i<nn;i++){
325: if (vv[i] >= 0) vv[i]= pow((float)vv[i], (float)p);
326: else vv[i]=TAO_INFINITY;
327: }
328: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
329: TaoFunctionReturn(0);
330: }
334: int TaoVecFloatArray::PointwiseMultiply( TaoVec* tv, TaoVec* tw ){
335: int i,nn1,nn2,nn3,info;
336: float *tptr1,*tptr2,*tptr3;
337: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
338: TaoVecFloatArray* ww = (TaoVecFloatArray*)(tw);
340: TaoFunctionBegin;
341: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
342: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
343: info = ww->GetFloats(&tptr3,&nn3);CHKERRQ(info);
344: for (i=0;i<nn1;i++) tptr1[i]=tptr2[i] * tptr3[i];
345: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
346: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
347: info = ww->RestoreFloats(&tptr3,&nn3);CHKERRQ(info);
349: TaoFunctionReturn(0);
350: }
354: int TaoVecFloatArray::PointwiseDivide( TaoVec* tv , TaoVec* tw){
355: int i,nn1,nn2,nn3,info;
356: float *tptr1,*tptr2,*tptr3;
357: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
358: TaoVecFloatArray* ww = (TaoVecFloatArray*)(tw);
360: TaoFunctionBegin;
361: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
362: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
363: info = ww->GetFloats(&tptr3,&nn3);CHKERRQ(info);
365: for (i=0;i<nn1;i++) tptr1[i]=tptr2[i] / tptr3[i];
366: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
367: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
368: info = ww->RestoreFloats(&tptr3,&nn3);CHKERRQ(info);
370: TaoFunctionReturn(0);
371: }
375: int TaoVecFloatArray::Median( TaoVec* tv, TaoVec* tw, TaoVec* tx){
376: int i,nn1,nn2,nn3,nn4,info;
377: float *tptr1,*tptr2,*tptr3,*tptr4;
378: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
379: TaoVecFloatArray* ww = (TaoVecFloatArray*)(tw);
380: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tx);
382: TaoFunctionBegin;
383: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
384: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
385: info = ww->GetFloats(&tptr3,&nn3);CHKERRQ(info);
386: info = xx->GetFloats(&tptr4,&nn4);CHKERRQ(info);
388: for (i=0;i<nn1;i++){
389: if (tptr2[i]<=tptr3[i] && tptr3[i] <= tptr4[i]){
390: tptr1[i]=tptr3[i];
391: } else if (tptr4[i]<=tptr3[i] && tptr3[i] <= tptr2[i]){
392: tptr1[i]=tptr3[i];
393: } else if (tptr3[i]<=tptr2[i] && tptr2[i] <= tptr4[i]){
394: tptr1[i]=tptr2[i];
395: } else if (tptr4[i]<=tptr2[i] && tptr2[i] <= tptr3[i]){
396: tptr1[i]=tptr2[i];
397: } else {
398: tptr1[i]=tptr4[i];
399: }
400: }
401: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
402: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
403: info = ww->RestoreFloats(&tptr3,&nn3);CHKERRQ(info);
404: info = xx->RestoreFloats(&tptr4,&nn4);CHKERRQ(info);
406: TaoFunctionReturn(0);
407: }
411: int TaoVecFloatArray::PointwiseMinimum( TaoVec* tv, TaoVec* tw){
412: int i,nn1,nn2,nn3,info;
413: float *tptr1,*tptr2,*tptr3;
414: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
415: TaoVecFloatArray* ww = (TaoVecFloatArray*)(tw);
417: TaoFunctionBegin;
418: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
419: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
420: info = ww->GetFloats(&tptr3,&nn3);CHKERRQ(info);
422: for (i=0;i<nn1;i++) tptr1[i] = TaoMin( tptr2[i] , tptr3[i]);
424: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
425: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
426: info = ww->RestoreFloats(&tptr3,&nn3);CHKERRQ(info);
428: TaoFunctionReturn(0);
429: }
433: int TaoVecFloatArray::PointwiseMaximum( TaoVec* tv, TaoVec* tw){
434: int i,nn1,nn2,nn3,info;
435: float *tptr1,*tptr2,*tptr3;
436: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
437: TaoVecFloatArray* ww = (TaoVecFloatArray*)(tw);
439: TaoFunctionBegin;
440: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
441: info = vv->GetFloats(&tptr2,&nn2);CHKERRQ(info);
442: info = ww->GetFloats(&tptr3,&nn3);CHKERRQ(info);
444: for (i=0;i<nn1;i++) tptr1[i] = TaoMax( tptr2[i] , tptr3[i]);
446: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
447: info = vv->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
448: info = ww->RestoreFloats(&tptr3,&nn3);CHKERRQ(info);
450: TaoFunctionReturn(0);
451: }
455: int TaoVecFloatArray::Waxpby ( double a, TaoVec* tx, double b, TaoVec* ty){
456: int i,nn1,nn2,nn3,info;
457: float *tptr1,*tptr2,*tptr3;
458: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tx);
459: TaoVecFloatArray* yy = (TaoVecFloatArray*)(ty);
461: TaoFunctionBegin;
462: info = this->GetFloats(&tptr1,&nn1);CHKERRQ(info);
463: info = xx->GetFloats(&tptr2,&nn2);CHKERRQ(info);
464: info = yy->GetFloats(&tptr3,&nn3);CHKERRQ(info);
465: if (nn1!=nn2 || nn2!=nn3) {TaoFunctionReturn(1);}
466: for (i=0;i<nn1;i++){ tptr1[i] = a * tptr2[i] + b * tptr3[i]; }
467: info = this->RestoreFloats(&tptr1,&nn1);CHKERRQ(info);
468: info = xx->RestoreFloats(&tptr2,&nn2);CHKERRQ(info);
469: info = yy->RestoreFloats(&tptr3,&nn3);CHKERRQ(info);
470: TaoFunctionReturn(0);
471: }
475: int TaoVecFloatArray::AbsoluteValue(){
476: int i,nn,info;
477: float *vv;
479: TaoFunctionBegin;
480: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
481: for (i=0;i<nn;i++){
482: vv[i]= TaoAbsScalar(vv[i]);
483: }
484: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
485: TaoFunctionReturn(0);
486: }
490: int TaoVecFloatArray::MinElement(double*val){
491: int i,nn,info;
492: float dd=TAO_INFINITY,*vv;
494: TaoFunctionBegin;
495: info = this->GetFloats(&vv,&nn);CHKERRQ(info);
496: for (i=0;i<nn;i++){
497: if (vv[i]<dd) dd=vv[i];
498: }
499: info = this->RestoreFloats(&vv,&nn);CHKERRQ(info);
500: *val = dd;
501: TaoFunctionReturn(0);
502: }
506: int TaoVecFloatArray::StepMax(TaoVec*tv,double*step1){
507: int i,nn1,nn2,info;
508: float *xx,*dx;
509: float stepmax1=TAO_INFINITY;
510: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
512: TaoFunctionBegin;
513: info = this->GetFloats(&xx,&nn1);CHKERRQ(info);
514: info = vv->GetFloats(&dx,&nn2);CHKERRQ(info);
515:
516: for (i=0;i<nn1;i++){
517: if (xx[i] < 0){
518: TaoFunctionReturn(1);
519: } else if (dx[i]<0){
520: stepmax1=TaoMin(stepmax1,-xx[i]/dx[i]);
521: }
522: }
523: *step1=stepmax1;
525: info = vv->RestoreFloats(&dx,&nn2);CHKERRQ(info);
526: info = this->RestoreFloats(&xx,&nn1);CHKERRQ(info);
527: TaoFunctionReturn(0);
528: }
532: int TaoVecFloatArray::StepMax2(TaoVec*tv,TaoVec*txl,TaoVec*txu, double*step2){
533: int i,nn1,nn2,info;
534: float *xx,*dx,*xl,*xu;
535: float stepmax2=0;
536: TaoVecFloatArray* vv = (TaoVecFloatArray*)(tv);
537: TaoVecFloatArray* xxll = (TaoVecFloatArray*)(txl);
538: TaoVecFloatArray* xxuu = (TaoVecFloatArray*)(txu);
540: TaoFunctionBegin;
541: info = this->GetFloats(&xx,&nn1);CHKERRQ(info);
542: info = vv->GetFloats(&dx,&nn2);CHKERRQ(info);
543: info = xxll->GetFloats(&xl,&nn2);CHKERRQ(info);
544: info = xxuu->GetFloats(&xu,&nn2);CHKERRQ(info);
545:
546: for (i=0;i<nn1;i++){
547: if (dx[i] > 0){
548: stepmax2=TaoMax(stepmax2,(xu[i]-xx[i])/dx[i]);
549: } else if (dx[i]<0){
550: stepmax2=TaoMax(stepmax2,(xl[i]-xx[i])/dx[i]);
551: }
552: }
553: info = this->RestoreFloats(&xx,&nn1);CHKERRQ(info);
554: info = vv->RestoreFloats(&dx,&nn2);CHKERRQ(info);
555: info = xxll->RestoreFloats(&xl,&nn2);CHKERRQ(info);
556: info = xxuu->RestoreFloats(&xu,&nn2);CHKERRQ(info);
557:
558: *step2=stepmax2;
559: TaoFunctionReturn(0);
560: }
565: int TaoVecFloatArray::BoundGradientProjection(TaoVec*tg,TaoVec*txl,TaoVec*tx, TaoVec*txu){
566: int i,nn1,nn2,nn3,nn4,nn5,info;
567: float *xptr,*xlptr,*xuptr,*gptr,*gpptr;
568: TaoVecFloatArray* gg = (TaoVecFloatArray*)(tg);
569: TaoVecFloatArray* xxll = (TaoVecFloatArray*)(txl);
570: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tx);
571: TaoVecFloatArray* xxuu = (TaoVecFloatArray*)(txu);
573: TaoFunctionBegin;
574: info = this->GetFloats(&gpptr,&nn1);CHKERRQ(info);
575: info = gg->GetFloats(&gptr,&nn2);CHKERRQ(info);
576: info = xxll->GetFloats(&xlptr,&nn3);CHKERRQ(info);
577: info = xx->GetFloats(&xptr,&nn4);CHKERRQ(info);
578: info = xxuu->GetFloats(&xuptr,&nn5);CHKERRQ(info);
579: if (nn1!=nn2 || nn2!=nn3 || nn3!=nn4 || nn4!=nn5) {TaoFunctionReturn(1);}
581: for (i=0; i<nn1; i++){
583: gpptr[i] = gptr[i];
584: if (gpptr[i]>0 && xptr[i]<=xlptr[i]){
585: gpptr[i] = 0;
586: } else if (gpptr[i]<0 && xptr[i]>=xuptr[i]){
587: gpptr[i] = 0;
588: }
589: }
590: info = this->RestoreFloats(&gpptr,&nn1);CHKERRQ(info);
591: info = gg->RestoreFloats(&gptr,&nn2);CHKERRQ(info);
592: info = xxll->RestoreFloats(&xlptr,&nn3);CHKERRQ(info);
593: info = xx->RestoreFloats(&xptr,&nn4);CHKERRQ(info);
594: info = xxuu->RestoreFloats(&xuptr,&nn5);CHKERRQ(info);
596: TaoFunctionReturn(0);
597: }
599: inline static float fischer(float a, float b)
600: {
602: #ifdef TODD
604: if (TaoAbsScalar(a) > TaoAbsScalar(b)) {
605: return sqrt(a*a + b*b) - a - b;
606: }
607: return sqrt(a*a + b*b) - b - a;
609: #else
611: // Method suggested by Bob Vanderbei
613: if (a + b <= 0) {
614: return sqrt(a*a + b*b) - (a + b);
615: }
616: return -2.0*a*b / (sqrt(a*a + b*b) + (a + b));
618: #endif
620: }
624: int TaoVecFloatArray::Fischer(TaoVec *tx, TaoVec *tf, TaoVec *tl, TaoVec *tu)
625: {
626: int i,nn1,nn2,nn3,nn4,nn5,info;
627: float *vv,*x,*f,*l,*u;
629: TaoVecFloatArray* xx = (TaoVecFloatArray*)(tx);
630: TaoVecFloatArray* ff = (TaoVecFloatArray*)(tf);
631: TaoVecFloatArray* ll = (TaoVecFloatArray*)(tl);
632: TaoVecFloatArray* uu = (TaoVecFloatArray*)(tu);
634: TaoFunctionBegin;
635: info = this->GetFloats(&vv,&nn1);CHKERRQ(info);
636: info = xx->GetFloats(&x,&nn2);CHKERRQ(info);
637: info = ff->GetFloats(&f,&nn3);CHKERRQ(info);
638: info = ll->GetFloats(&l,&nn4);CHKERRQ(info);
639: info = uu->GetFloats(&u,&nn5);CHKERRQ(info);
640: if (nn1!=nn2 || nn2!=nn3 || nn3!=nn4 || nn4!=nn5) {
641: TaoFunctionReturn(1);
642: }
644: for (i=0;i<nn1;i++) {
646: if ((l[i] <= -TAO_INFINITY) && (u[i] >= TAO_INFINITY)) {
647: vv[i] = -f[i];
648: }
649: else if (l[i] <= -TAO_INFINITY) {
650: vv[i] = -fischer(u[i] - x[i], -f[i]);
651: }
652: else if (u[i] >= TAO_INFINITY) {
653: vv[i] = fischer(x[i] - l[i], f[i]);
654: }
655: else if (l[i] == u[i]) {
656: vv[i] = l[i] - x[i];
657: }
658: else {
659: vv[i] = fischer(u[i] - x[i], -f[i]);
660: vv[i] = fischer(x[i] - l[i], vv[i]);
661: }
663: }
665: info = this->RestoreFloats(&vv,&nn1);CHKERRQ(info);
666: info = xx->RestoreFloats(&x,&nn2);CHKERRQ(info);
667: info = ff->RestoreFloats(&f,&nn3);CHKERRQ(info);
668: info = ll->RestoreFloats(&l,&nn4);CHKERRQ(info);
669: info = uu->RestoreFloats(&u,&nn5);CHKERRQ(info);
671: TaoFunctionReturn(0);
672: }
674: inline static float sfischer(float a, float b, float c)
675: {
677: #ifdef TODD
679: if (TaoAbsScalar(a) > TaoAbsScalar(b)) {
680: return sqrt(a*a + b*b + 2.0*c*c) - a - b;
681: }
682: return sqrt(a*a + b*b + 2.0*c*c) - b - a;
684: #else
686: // Method suggested by Bob Vanderbei
688: if (a + b <= 0) {
689: return sqrt(a*a + b*b + 2.0*c*c) - (a + b);
690: }
691: return 2.0*(c*c - a*b) / (sqrt(a*a + b*b + 2.0*c*c) + (a + b));
693: #endif
695: }
699: int TaoVecFloatArray::SFischer(TaoVec *tx, TaoVec *tf, TaoVec *tl, TaoVec *tu, double mu)
700: {
701: int i, nn1, nn2, nn3, nn4, nn5, info;
702: float *vv, *x, *f, *l, *u;
704: TaoVecFloatArray *xx = (TaoVecFloatArray *)(tx);
705: TaoVecFloatArray *ff = (TaoVecFloatArray *)(tf);
706: TaoVecFloatArray *ll = (TaoVecFloatArray *)(tl);
707: TaoVecFloatArray *uu = (TaoVecFloatArray *)(tu);
709: TaoFunctionBegin;
711: if ((mu >= -TAO_EPSILON) && (mu <= TAO_EPSILON)) {
712: Fischer(tx, tf, tl, tu);
713: }
714: else {
715: info = this->GetFloats(&vv, &nn1); CHKERRQ(info);
716: info = xx->GetFloats(&x, &nn2); CHKERRQ(info);
717: info = ff->GetFloats(&f, &nn3); CHKERRQ(info);
718: info = ll->GetFloats(&l, &nn4); CHKERRQ(info);
719: info = uu->GetFloats(&u, &nn5); CHKERRQ(info);
721: if (nn1!=nn2 || nn2!=nn3 || nn3!=nn4 || nn4!=nn5) {
722: TaoFunctionReturn(1);
723: }
725: for (i = 0; i < nn1; ++i) {
726: if ((l[i] <= -TAO_INFINITY) && (u[i] >= TAO_INFINITY)) {
727: vv[i] = -f[i] - mu*x[i];
728: }
729: else if (l[i] <= -TAO_INFINITY) {
730: vv[i] = -sfischer(u[i] - x[i], -f[i], mu);
731: }
732: else if (u[i] >= TAO_INFINITY) {
733: vv[i] = sfischer(x[i] - l[i], f[i], mu);
734: }
735: else if (l[i] == u[i]) {
736: vv[i] = l[i] - x[i];
737: }
738: else {
739: vv[i] = sfischer(u[i] - x[i], -f[i], mu);
740: vv[i] = sfischer(x[i] - l[i], vv[i], mu);
741: }
742: }
744: info = this->RestoreFloats(&vv, &nn1); CHKERRQ(info);
745: info = xx->RestoreFloats(&x, &nn2); CHKERRQ(info);
746: info = ff->RestoreFloats(&f, &nn3); CHKERRQ(info);
747: info = ll->RestoreFloats(&l, &nn4); CHKERRQ(info);
748: info = uu->RestoreFloats(&u, &nn5); CHKERRQ(info);
749: }
750: TaoFunctionReturn(0);
751: }