void command(void) { char buffer[100]; printf(">"); fscanf( stdin, "%s", buffer ); if ( !strcmp( buffer, "insert" ) ) { insert(); return; } else if ( !strcmp( buffer, "update" ) ) { update(); return; } else if ( !strcmp( buffer, "delete" ) ) { delete_(); return; } else if ( !strcmp( buffer, "sort" ) ) { sort_(); return; } else if ( !strcmp( buffer, "show" ) ) { show(); return; } else if ( !strcmp( buffer, "save" ) ) { save(); return; } else if ( !strcmp( buffer, "exit" ) ) { exit_(); return; } else { printf("Wrong command!\n"); return; } }
C_FLOAT64 CPraxis::praxis_(C_FLOAT64 *t0, C_FLOAT64 *machep, C_FLOAT64 *h0, C_INT *n, C_INT *prin, C_FLOAT64 *x, FPraxis *f, C_FLOAT64 *fmin) { /* System generated locals */ C_INT i__1, i__2, i__3; C_FLOAT64 ret_val, d__1; /* Local variables */ static C_FLOAT64 scbd; static C_INT idim; static bool illc; static C_INT klmk; static C_FLOAT64 d__[100], h__, ldfac; static C_INT i__, j, k; static C_FLOAT64 s, t, y[100], large, z__[100], small, value, f1; static C_INT k2; static C_FLOAT64 m2, m4, t2, df, dn; static C_INT kl, ii; static C_FLOAT64 sf; static C_INT kt; static C_FLOAT64 sl, vlarge; static C_FLOAT64 vsmall; static C_INT km1, im1; static C_FLOAT64 dni, lds; static C_INT ktm; C_FLOAT64 lastValue = std::numeric_limits<C_FLOAT64>::infinity(); /* LAST MODIFIED 3/1/73 */ /* PRAXIS RETURNS THE MINIMUM OF THE FUNCTION F(X,N) OF N VARIABLES */ /* USING THE PRINCIPAL AXIS METHOD. THE GRADIENT OF THE FUNCTION IS */ /* NOT REQUIRED. */ /* FOR A DESCRIPTION OF THE ALGORITHM, SEE CHAPTER SEVEN OF */ /* "ALGORITHMS FOR FINDING ZEROS AND EXTREMA OF FUNCTIONS WITHOUT */ /* CALCULATING DERIVATIVES" BY RICHARD P BRENT. */ /* THE PARAMETERS ARE: */ /* T0 IS A TOLERANCE. PRAXIS ATTEMPTS TO RETURN PRAXIS=F(X) */ /* SUCH THAT IF X0 IS THE TRUE LOCAL MINIMUM NEAR X, THEN */ /* NORM(X-X0) < T0 + SQUAREROOT(MACHEP)*NORM(X). */ /* MACHEP IS THE MACHINE PRECISION, THE SMALLEST NUMBER SUCH THAT */ /* 1 + MACHEP > 1. MACHEP SHOULD BE 16.**-13 (ABOUT */ /* 2.22D-16) FOR REAL*8 ARITHMETIC ON THE IBM 360. */ /* H0 IS THE MAXIMUM STEP SIZE. H0 SHOULD BE SET TO ABOUT THE */ /* MAXIMUM DISTANCE FROM THE INITIAL GUESS TO THE MINIMUM. */ /* (IF H0 IS SET TOO LARGE OR TOO SMALL, THE INITIAL RATE OF */ /* CONVERGENCE MAY BE SLOW.) */ /* N (AT LEAST TWO) IS THE NUMBER OF VARIABLES UPON WHICH */ /* THE FUNCTION DEPENDS. */ /* PRIN CONTROLS THE PRINTING OF INTERMEDIATE RESULTS. */ /* IF PRIN=0, NOTHING IS PRINTED. */ /* IF PRIN=1, F IS PRINTED AFTER EVERY N+1 OR N+2 LINEAR */ /* MINIMIZATIONS. FINAL X IS PRINTED, BUT INTERMEDIATE X IS */ /* PRINTED ONLY IF N IS AT MOST 4. */ /* IF PRIN=2, THE SCALE FACTORS AND THE PRINCIPAL VALUES OF */ /* THE APPROXIMATING QUADRATIC FORM ARE ALSO PRINTED. */ /* IF PRIN=3, X IS ALSO PRINTED AFTER EVERY FEW LINEAR */ /* MINIMIZATIONS. */ /* IF PRIN=4, THE PRINCIPAL VECTORS OF THE APPROXIMATING */ /* QUADRATIC FORM ARE ALSO PRINTED. */ /* X IS AN ARRAY CONTAINING ON ENTRY A GUESS OF THE POINT OF */ /* MINIMUM, ON RETURN THE ESTIMATED POINT OF MINIMUM. */ /* F(X,N) IS THE FUNCTION TO BE MINIMIZED. F SHOULD BE A REAL*8 */ /* FUNCTION DECLARED EXTERNAL IN THE CALLING PROGRAM. */ /* FMIN IS AN ESTIMATE OF THE MINIMUM, USED ONLY IN PRINTING */ /* INTERMEDIATE RESULTS. */ /* THE APPROXIMATING QUADRATIC FORM IS */ /* Q(X') = F(X,N) + (1/2) * (X'-X)-TRANSPOSE * A * (X'-X) */ /* WHERE X IS THE BEST ESTIMATE OF THE MINIMUM AND A IS */ /* INVERSE(V-TRANSPOSE) * D * INVERSE(V) */ /* (V(*,*) IS THE MATRIX OF SEARCH DIRECTIONS; D(*) IS THE ARRAY */ /* OF SECOND DIFFERENCES). IF F HAS CONTINUOUS SECOND DERIVATIVES */ /* NEAR X0, A WILL TEND TO THE HESSIAN OF F AT X0 AS X APPROACHES X0. */ /* IT IS ASSUMED THAT ON FLOATING-POINT UNDERFLOW THE RESULT IS SET */ /* TO ZERO. */ /* THE USER SHOULD OBSERVE THE COMMENT ON HEURISTIC NUMBERS AFTER */ /* THE INITIALIZATION OF MACHINE DEPENDENT NUMBERS. */ /* .....IF N>20 OR IF N<20 AND YOU NEED MORE SPACE, CHANGE '20' TO THE */ /* LARGEST VALUE OF N IN THE NEXT CARD, IN THE CARD 'IDIM=20', AND */ /* IN THE DIMENSION STATEMENTS IN SUBROUTINES MINFIT,MIN,FLIN,QUAD. */ /* .....INITIALIZATION..... */ /* MACHINE DEPENDENT NUMBERS: */ /* Parameter adjustments */ --x; /* Function Body */ small = *machep * *machep; vsmall = small * small; large = 1. / small; vlarge = 1. / vsmall; m2 = sqrt(*machep); m4 = sqrt(m2); /* HEURISTIC NUMBERS: */ /* IF THE AXES MAY BE BADLY SCALED (WHICH IS TO BE AVOIDED IF */ /* POSSIBLE), THEN SET SCBD=10. OTHERWISE SET SCBD=1. */ /* IF THE PROBLEM IS KNOWN TO BE ILL-CONDITIONED, SET ILLC=TRUE. */ /* OTHERWISE SET ILLC=FALSE. */ /* KTM IS THE NUMBER OF ITERATIONS WITHOUT IMPROVEMENT BEFORE THE */ /* ALGORITHM TERMINATES. KTM=4 IS VERY CAUTIOUS; USUALLY KTM=1 */ /* IS SATISFACTORY. */ scbd = 1.; illc = FALSE_; ktm = 1; ldfac = .01; if (illc) { ldfac = .1; } kt = 0; global_1.nl = 0; global_1.nf = 1; global_1.fx = (*f)(&x[1], n); q_1.qf1 = global_1.fx; t = small + fabs(*t0); t2 = t; global_1.dmin__ = small; h__ = *h0; if (h__ < t * 100) { h__ = t * 100; } global_1.ldt = h__; /* .....THE FIRST SET OF SEARCH DIRECTIONS V IS THE IDENTITY MATRIX..... */ i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { i__2 = *n; for (j = 1; j <= i__2; ++j) { /* L10: */ q_1.v[i__ + j * 100 - 101] = 0.; } /* L20: */ q_1.v[i__ + i__ * 100 - 101] = 1.; } d__[0] = 0.; q_1.qd0 = 0.; i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { q_1.q0[i__ - 1] = x[i__]; /* L30: */ q_1.q1[i__ - 1] = x[i__]; } if (*prin > 0) { print_(n, &x[1], prin, fmin); } /* .....THE MAIN LOOP STARTS HERE..... */ L40: sf = d__[0]; d__[0] = 0.; s = 0.; /* .....MINIMIZE ALONG THE FIRST DIRECTION V(*,1). */ /* FX MUST BE PASSED TO MIN BY VALUE. */ value = global_1.fx; min_(n, &c__1, &c__2, d__, &s, &value, &c_false, f, &x[1], &t, machep, &h__); if (s > 0.) { goto L50; } i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { /* L45: */ q_1.v[i__ - 1] = -q_1.v[i__ - 1]; } L50: if (sf > d__[0] * .9 && sf * .9 < d__[0]) { goto L70; } i__1 = *n; for (i__ = 2; i__ <= i__1; ++i__) { /* L60: */ d__[i__ - 1] = 0.; } /* .....THE INNER LOOP STARTS HERE..... */ L70: i__1 = *n; for (k = 2; k <= i__1; ++k) { i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { /* L75: */ y[i__ - 1] = x[i__]; } sf = global_1.fx; if (kt > 0) { illc = TRUE_; } L80: kl = k; df = 0.; /* .....A RANDOM STEP FOLLOWS (TO AVOID RESOLUTION VALLEYS). */ /* PRAXIS ASSUMES THAT RANDOM RETURNS A RANDOM NUMBER UNIFORMLY */ /* DISTRIBUTED IN (0,1). */ if (! illc) { goto L95; } i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { s = (global_1.ldt * .1 + t2 * pow(10.0, (C_FLOAT64)kt)) * (mpRandom->getRandomCC() - 0.5); z__[i__ - 1] = s; i__3 = *n; for (j = 1; j <= i__3; ++j) { /* L85: */ x[j] += s * q_1.v[j + i__ * 100 - 101]; } /* L90: */ } global_1.fx = (*f)(&x[1], n); ++global_1.nf; /* .....MINIMIZE ALONG THE "NON-CONJUGATE" DIRECTIONS V(*,K),...,V(*,N ) */ L95: i__2 = *n; for (k2 = k; k2 <= i__2; ++k2) { sl = global_1.fx; s = 0.; value = global_1.fx; min_(n, &k2, &c__2, &d__[k2 - 1], &s, &value, &c_false, f, & x[1], &t, machep, &h__); if (illc) { goto L97; } s = sl - global_1.fx; goto L99; L97: /* Computing 2nd power */ d__1 = s + z__[k2 - 1]; s = d__[k2 - 1] * (d__1 * d__1); L99: if (df > s) { goto L105; } df = s; kl = k2; L105: ; } if (illc || df >= (d__1 = *machep * 100 * global_1.fx, fabs(d__1))) { goto L110; } /* .....IF THERE WAS NOT MUCH IMPROVEMENT ON THE FIRST TRY, SET */ /* ILLC=TRUE AND START THE INNER LOOP AGAIN..... */ illc = TRUE_; goto L80; L110: if (k == 2 && *prin > 1) { vcprnt_(&c__1, d__, n); } /* .....MINIMIZE ALONG THE "CONJUGATE" DIRECTIONS V(*,1),...,V(*,K-1) */ km1 = k - 1; i__2 = km1; for (k2 = 1; k2 <= i__2; ++k2) { s = 0.; value = global_1.fx; min_(n, &k2, &c__2, &d__[k2 - 1], &s, &value, &c_false, f, & x[1], &t, machep, &h__); /* L120: */ } f1 = global_1.fx; global_1.fx = sf; lds = 0.; i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { sl = x[i__]; x[i__] = y[i__ - 1]; sl -= y[i__ - 1]; y[i__ - 1] = sl; /* L130: */ lds += sl * sl; } lds = sqrt(lds); if (lds <= small) { goto L160; } /* .....DISCARD DIRECTION V(*,KL). */ /* IF NO RANDOM STEP WAS TAKEN, V(*,KL) IS THE "NON-CONJUGATE" */ /* DIRECTION ALONG WHICH THE GREATEST IMPROVEMENT WAS MADE..... */ klmk = kl - k; if (klmk < 1) { goto L141; } i__2 = klmk; for (ii = 1; ii <= i__2; ++ii) { i__ = kl - ii; i__3 = *n; for (j = 1; j <= i__3; ++j) { /* L135: */ q_1.v[j + (i__ + 1) * 100 - 101] = q_1.v[j + i__ * 100 - 101]; } /* L140: */ d__[i__] = d__[i__ - 1]; } L141: d__[k - 1] = 0.; i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { /* L145: */ q_1.v[i__ + k * 100 - 101] = y[i__ - 1] / lds; } /* .....MINIMIZE ALONG THE NEW "CONJUGATE" DIRECTION V(*,K), WHICH IS */ /* THE NORMALIZED VECTOR: (NEW X) - (0LD X)..... */ value = f1; min_(n, &k, &c__4, &d__[k - 1], &lds, &value, &c_true, f, &x[1], &t, machep, &h__); if (lds > 0.) { goto L160; } lds = -lds; i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { /* L150: */ q_1.v[i__ + k * 100 - 101] = -q_1.v[i__ + k * 100 - 101]; } L160: global_1.ldt = ldfac * global_1.ldt; if (global_1.ldt < lds) { global_1.ldt = lds; } if (*prin > 0) { print_(n, &x[1], prin, fmin); } t2 = 0.; i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { /* L165: */ /* Computing 2nd power */ d__1 = x[i__]; t2 += d__1 * d__1; } t2 = m2 * sqrt(t2) + t; /* .....SEE WHETHER THE LENGTH OF THE STEP TAKEN SINCE STARTING THE */ /* INNER LOOP EXCEEDS HALF THE TOLERANCE..... */ if (global_1.ldt > t2 * .5f) { kt = -1; } ++kt; if (kt > ktm) { goto L400; } /* L170: */ } /* added manually by Pedro Mendes 11/11/1998 */ // if(callback != 0/*NULL*/) callback(global_1.fx); /* .....THE INNER LOOP ENDS HERE. */ /* TRY QUADRATIC EXTRAPOLATION IN CASE WE ARE IN A CURVED VALLEY. */ /* L171: */ quad_(n, f, &x[1], &t, machep, &h__); dn = 0.; i__1 = *n; for (i__ = 1; i__ <= i__1; ++i__) { d__[i__ - 1] = 1. / sqrt(d__[i__ - 1]); if (dn < d__[i__ - 1]) { dn = d__[i__ - 1]; } /* L175: */ } if (*prin > 3) { maprnt_(&c__1, q_1.v, &idim, n); } i__1 = *n; for (j = 1; j <= i__1; ++j) { s = d__[j - 1] / dn; i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { /* L180: */ q_1.v[i__ + j * 100 - 101] = s * q_1.v[i__ + j * 100 - 101]; } } /* .....SCALE THE AXES TO TRY TO REDUCE THE CONDITION NUMBER..... */ if (scbd <= 1.) { goto L200; } s = vlarge; i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { sl = 0.; i__1 = *n; for (j = 1; j <= i__1; ++j) { /* L182: */ sl += q_1.v[i__ + j * 100 - 101] * q_1.v[i__ + j * 100 - 101]; } z__[i__ - 1] = sqrt(sl); if (z__[i__ - 1] < m4) { z__[i__ - 1] = m4; } if (s > z__[i__ - 1]) { s = z__[i__ - 1]; } /* L185: */ } i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { sl = s / z__[i__ - 1]; z__[i__ - 1] = 1. / sl; if (z__[i__ - 1] <= scbd) { goto L189; } sl = 1. / scbd; z__[i__ - 1] = scbd; L189: i__1 = *n; for (j = 1; j <= i__1; ++j) { /* L190: */ q_1.v[i__ + j * 100 - 101] = sl * q_1.v[i__ + j * 100 - 101]; } /* L195: */ } /* .....CALCULATE A NEW SET OF ORTHOGONAL DIRECTIONS BEFORE REPEATING */ /* THE MAIN LOOP. */ /* FIRST TRANSPOSE V FOR MINFIT: */ L200: i__2 = *n; for (i__ = 2; i__ <= i__2; ++i__) { im1 = i__ - 1; i__1 = im1; for (j = 1; j <= i__1; ++j) { s = q_1.v[i__ + j * 100 - 101]; q_1.v[i__ + j * 100 - 101] = q_1.v[j + i__ * 100 - 101]; /* L210: */ q_1.v[j + i__ * 100 - 101] = s; } /* L220: */ } /* .....CALL MINFIT TO FIND THE SINGULAR VALUE DECOMPOSITION OF V. */ /* THIS GIVES THE PRINCIPAL VALUES AND PRINCIPAL DIRECTIONS OF THE */ /* APPROXIMATING QUADRATIC FORM WITHOUT SQUARING THE CONDITION */ /* NUMBER..... */ minfit_(&idim, n, machep, &vsmall, q_1.v, d__); /* .....UNSCALE THE AXES..... */ if (scbd <= 1.) { goto L250; } i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { s = z__[i__ - 1]; i__1 = *n; for (j = 1; j <= i__1; ++j) { /* L225: */ q_1.v[i__ + j * 100 - 101] = s * q_1.v[i__ + j * 100 - 101]; } /* L230: */ } i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { s = 0.; i__1 = *n; for (j = 1; j <= i__1; ++j) { /* L235: */ /* Computing 2nd power */ d__1 = q_1.v[j + i__ * 100 - 101]; s += d__1 * d__1; } s = sqrt(s); d__[i__ - 1] = s * d__[i__ - 1]; s = 1 / s; i__1 = *n; for (j = 1; j <= i__1; ++j) { /* L240: */ q_1.v[j + i__ * 100 - 101] = s * q_1.v[j + i__ * 100 - 101]; } /* L245: */ } L250: i__2 = *n; for (i__ = 1; i__ <= i__2; ++i__) { dni = dn * d__[i__ - 1]; if (dni > large) { goto L265; } if (dni < small) { goto L260; } d__[i__ - 1] = 1 / (dni * dni); goto L270; L260: d__[i__ - 1] = vlarge; goto L270; L265: d__[i__ - 1] = vsmall; L270: ; } /* .....SORT THE EIGENVALUES AND EIGENVECTORS..... */ sort_(&idim, n, d__, q_1.v); global_1.dmin__ = d__[*n - 1]; if (global_1.dmin__ < small) { global_1.dmin__ = small; } illc = FALSE_; if (m2 * d__[0] > global_1.dmin__) { illc = TRUE_; } if (*prin > 1 && scbd > 1.) { vcprnt_(&c__2, z__, n); } if (*prin > 1) { vcprnt_(&c__3, d__, n); } if (*prin > 3) { maprnt_(&c__2, q_1.v, &idim, n); } /* .....THE MAIN LOOP ENDS HERE..... */ /* added manually by Pedro Mendes 29/1/1998 */ /* if(callback != 0) callback(global_1.fx);*/ // We need a stopping condition for 1 dimensional problems. // We compare the values between the last and current steps. if (*n > 1 || global_1.fx < lastValue) { lastValue = global_1.fx; goto L40; } /* .....RETURN..... */ L400: if (*prin > 0) { vcprnt_(&c__4, &x[1], n); } ret_val = global_1.fx; return ret_val; } /* praxis_ */
void IsotopeDistribution::sortByIntensity() { sort_([](const MassAbundance& p1, const MassAbundance& p2){ return p1.getIntensity() > p2.getIntensity(); }); }
void IsotopeDistribution::sortByMass() { sort_([](const MassAbundance& p1, const MassAbundance& p2){ return p1.getMZ() < p2.getMZ(); }); }
Fl_Node* Fl_Tree::sort_tree(Fl_Node* start, int (*compar)(Fl_Node *, Fl_Node*), sort_order order) { if (first_) return sort_(start, compar, 1, order); return 0; }
bool operator()(const DOM::Node<std::string>& n1, const DOM::Node<std::string>& n2) { return sort_(n1, n2); } // operator()
void readVector( int v[], int n ) { sort_( v, n ); min_ = v[0]; max_ = v[n-1]; med_ = v[n/2]; }
int dm_sort_cols (matrix_t *r, matrix_t *mayw, matrix_t *mustw, dm_comparator_fn cmp) { return sort_ (r, mayw, mustw, cmp, dm_ncols (r), dm_swap_cols); }
bool operator()(const DOMNode& n1, const DOMNode& n2) { return sort_(n1, n2); } // operator()