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()
