Sindbad~EG File Manager

/* M. Beeson for MathXpert
   inequality operators, variants to appear on menus with > and GE
   in the menu strings.  All these operators just call old operators
   that work indiscriminately on any inequality, be it > or < or LE or GE,
   but in order for the dynamic error-message generation to work right,
   and for ShowStep to work right, we have to be able to pinpoint a menu
   string with the right sense of inequality, so we need separate operators
   to correspond to the menus strings.
*/
/*
Original date 6.27.96
Last modified 1.22.98
*/

#include <string.h>
#include <assert.h>
#include <search.h>
#include "globals.h"
#include "ops.h"
/*_______________________________________________________________*/
int sqrtineq11g(term t, term arg, term *next, char *reason)
/* a > u^2 iff \sqrt a > |u|              */
{ return sqrtineq11(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq14g(term t, term arg, term *next, char *reason)
/* a > u^2 iff -\sqrt a < u < \sqrt a          */
{ return sqrtineq14(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq12g(term t, term arg, term *next, char *reason)
/* v^2 > a iff |v| > \sqrt a provided a>=0 */
{ return sqrtineq12(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq15g(term t, term arg, term *next, char *reason)
/* u^2 > a iff u < -\sqrt a  or u > \sqrt a    */
{ return sqrtineq15(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq11g(term t, term arg, term *next, char *reason)
/* v > \sqrt u iff 0  \le  u < v^2            */
{ return powerineq11(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squareineq1g(term t, term arg, term *next, char *reason)
/* v>a\sqrt u iff 0 \le a^2u<v^2 provided 0 \le a  */
{ return squareineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq12g(term t, term arg, term *next, char *reason)
/* \sqrt v > a iff v > a^2 provided 0 \le a   */
{ return powerineq12(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq13g(term t, term arg, term *next, char *reason)
/* v > u  iff \sqrt v > \sqrt u provided u>=0  */
{ return sqrtineq13(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq21g(term t, term arg, term *next, char *reason)
/* a >= u^2 iff \sqrt a >= |u|            */
{ return sqrtineq12(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq24g(term t, term arg, term *next, char *reason)
/* a >= u^2 iff -\sqrt a  \le  u  \le  \sqrt a        */
{ return sqrtineq24(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq22g(term t, term arg, term *next, char *reason)
/* v^2 >= a iff |v| >= \sqrt a provided 0 \le a */
{ return sqrtineq22(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq25g(term t, term arg, term *next, char *reason)
/* u^2 >= a iff u  \le  -\sqrt a or \sqrt a  \le  u   */
{ return sqrtineq25(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq21g(term t, term arg, term *next, char *reason)
/* v >= \sqrt u iff 0  \le  u  \le  v^2          */
{ return sqrtineq21(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squareineq2g(term t, term arg, term *next, char *reason)
/* v >= a\sqrt u iff 0 \le a^2u \le v^2 provided 0 \le a */
{ return squareineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq22g(term t, term arg, term *next, char *reason)
/* \sqrt v >= a iff v >= a^2 provided 0 \le a */
{ return powerineq22(t,arg,next,reason);
}
/*_______________________________________________________________*/
int sqrtineq23g(term t, term arg, term *next, char *reason)
/* v >= u iff \sqrt v >= \sqrt u provided u>=0 */
{ return sqrtineq23(t,arg,next,reason);
}
/*_______________________________________________________________*/
int oddrootineqg(term t, term arg, term *next, char *reason)
/* u > v iff root(n,u) > root(n,v) (n odd)          */
{ return oddrootineq(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq11g(term t, term arg, term *next, char *reason)
/* a > u^2n iff sqrt(a) > |u|               */
{ return rootineq11(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq13g(term t, term arg, term *next, char *reason)
/* a > u^(2n) iff -root(2n,a) < u < root(2n,a)         */
{ return rootineq13(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq12g(term t, term arg, term *next, char *reason)
/* u^(2n) > a iff |u| > root(2n,a)  provided a>=0 */
{ return rootineq12(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq15g(term t, term arg, term *next, char *reason)
/* u^(2n) > a iff u < -root(2n,a)  or u > root(2n,a)   */
{ return rootineq15(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq14eveng(term t, term arg, term *next, char *reason)
/* v > root(2n, u)  iff 0  \le  u < v^(2n)            */
{ return powerineq14even(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq14oddg(term t, term arg, term *next, char *reason)
/* v > root(2n,u)  iff 0  \le  u < v^(2n)            */
{ return powerineq14odd(t,arg,next,reason);
}

/*_______________________________________________________________*/
int powerineq13g(term t, term arg, term *next, char *reason)
/* v > a root(n,u) iff v^n > a^n u provided 0  \le  a root(n,u) */
{ return powerineq13(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq15g(term t, term arg, term *next, char *reason)
/* root(n,v) > a iff v > a^n provided a>=0      */
{ return powerineq15(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq16g(term t, term arg, term *next, char *reason)
/* u > v iff u^n > v^n (n odd, n>0)       */
{ return powerineq16(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq17g(term t, term arg, term *next, char *reason)
/* u > v iff u^n > v^n (n > 0 and 0  \le  u) */
{ return powerineq17(t,arg,next,reason);
}
/*_______________________________________________________________*/
int oddrootineq2g(term t, term arg, term *next, char *reason)
/* u >= v iff root(n, u) >= root(n,v) (n odd)          */
{ return oddrootineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq21g(term t, term arg, term *next, char *reason)
/* a >= u^(2n) iff sqrt(a) >= |u|                */
{ return rootineq21(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq23g(term t, term arg, term *next, char *reason)
/* a >= u^(2n) iff -sqrt(a)  \le  u  \le  sqrt(a)          */
{ return rootineq23(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq22g(term t, term arg, term *next, char *reason)
/* u^(2n) > a iff |u| > sqrt(a)  provided a>=0  */
{ return rootineq22(t,arg,next,reason);
}
/*_______________________________________________________________*/
int rootineq25g(term t, term arg, term *next, char *reason)
/* u^(2n) >= a iff u  \le  -sqrt(a)  or u >= sqrt(a)    */
{ return rootineq25(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq24eveng(term t, term arg, term *next, char *reason)
/* v >= ^(2n)\sqrt u iff 0  \le  u  \le  v^(2n)              */
{ return powerineq24even(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq24oddg(term t, term arg, term *next, char *reason)
/* v >= root(2n,u) iff 0  \le  u  \le  v^(2n)              */
{ return powerineq24odd(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq23g(term t, term arg, term *next, char *reason)
/* v >= a root(n,u) iff v^n >= a^n u provided 0  \le  a root(n,u) */
{ return powerineq23(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq25g(term t, term arg, term *next, char *reason)
/* root(n,v) >= a iff a^n  \le  v provided a >= 0     */
{ return powerineq25(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq26g(term t, term arg, term *next, char *reason)
/* u >= v iff u^n >= v^n (n odd, n >= 0)      */
{ return powerineq26(t,arg,next,reason);
}
/*_______________________________________________________________*/
int powerineq27g(term t, term arg, term *next, char *reason)
/* u >= v iff u^n >= v^n (n > 0 and 0  \le  u)  */
{ return powerineq27(t,arg,next,reason);
}
/*_______________________________________________________________*/
int posnum1g(term t, term arg, term *next, char *reason)
/* u/v > 0 iff v > 0 provided u > 0 */
{ return posnum1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int mulineqsqrt1g(term t, term arg, term *next, char *reason)
/* change u/\sqrt v > 0 to uv > 0        */
{ return mulineqsqrt1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int mulineqbysquare1g(term t, term arg, term *next, char *reason)
/* u/v > 0 iff uv > 0               */
{ return mulineqbysquare1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int mulineqsqrt2g(term t, term arg, term *next, char *reason)
/* change 0 > u/\sqrt v to 0 > uv        */
{ return mulineqsqrt2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int mulineqbysquare2g(term t, term arg, term *next, char *reason)
/* 0 > u/v iff 0 > uv               */
{ return mulineqbysquare2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int normalizelinear1g(term t, term arg, term *next, char *reason)
/* 0 > ax  \pm  b iff 0 > a(x \pm b/a)      */
{ return normalizelinear1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int reverselessthang(term t, term arg, term *next, char *reason)
/* 0 > ax  \pm  b iff 0 > a(x \pm b/a)      */
{ return reverselessthan(t,arg,next,reason);
}
/*_______________________________________________________________*/
int intervalsneg1g(term t, term arg, term *next, char *reason)
/* 0 > (x-a)(x-b) iff a<x<b  (where a<b) */
{ return intervalsneg1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int intervalspos1g(term t, term arg, term *next, char *reason)
/* (x-a)(x-b)> 0 iff x<a or x>b (where a<b) */
{ return intervalspos1(t,arg,next,reason);
}

/*_______________________________________________________________*/
int posnum2g(term t, term arg, term *next, char *reason)
/* u/v >= 0 iff v >= 0 provided u >= 0  */
{ return posnum2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int mulineqsqrt3g(term t, term arg, term *next, char *reason)
/* u/\sqrt v >= 0 iff uv >= 0               */
{ return mulineqsqrt3(t,arg,next,reason);
}
/*_______________________________________________________________*/
int mulineqbysquare3g(term t, term arg, term *next, char *reason)
/* u/v >= 0 iff uv > 0 or u = 0       */
{ return mulineqbysquare3(t,arg,next,reason);
}
/*_______________________________________________________________*/
int mulineqsqrt4g(term t, term arg, term *next, char *reason)
/* 0 >= u/\sqrt v iff 0 >= uv               */
{ return mulineqsqrt4(t,arg,next,reason);
}

/*_______________________________________________________________*/
int mulineqbysquare4g(term t, term arg, term *next, char *reason)
/* 0 >= u/v iff 0 > uv or u = 0       */
{ return mulineqbysquare4(t,arg,next,reason);
}
/*_______________________________________________________________*/
int normalizelinear2g(term t, term arg, term *next, char *reason)
/* 0 >= ax  \pm  b iff 0 >= a(x \pm b/a)       */
{ return normalizelinear2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int intervalsneg2g(term t, term arg, term *next, char *reason)
/* 0 >= (x-a)(x-b) iff a \le x \le b (where a \le b) */
{ return intervalsneg2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int intervalspos2g(term t, term arg, term *next, char *reason)
/* (x-a)(x-b)>=0 iff x \le a or b \le x (where a \le b) */
{ return intervalspos2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squareineq3g(term t, term arg, term *next, char *reason)
/* square both sides when one side is >= 0,
but the ophelp text is different for > and < */
{ return squareineq3(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squareineq4g(term t, term arg, term *next, char *reason)
/* square both sides when one side is >= 0,
but the ophelp text is different for > and < */
{ return squareineq4(t,arg,next,reason);
}

/*_______________________________________________________________*/
int evenpowerineq1g(term t, term arg, term *next, char *reason)
/* x^2n > a is true if a < 0         */
{ return evenpowerineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int evenpowerineq2g(term t, term arg, term *next, char *reason)
/* x^2n >= a is true if a >= 0         */
{ return evenpowerineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int evenpowerineq3g(term t, term arg, term *next, char *reason)
/* x^2n < a is false if a  \le  0        */
{ return evenpowerineq3(t,arg,next,reason);
}
/*_______________________________________________________________*/
int evenpowerineq4g(term t, term arg, term *next, char *reason)
/* x^2n  \le  a is false if a < 0        */
{ return evenpowerineq4(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq11g(term t, term arg, term *next, char *reason)
 /* a > 1/x  iff x<0 or x > 1/a provided a > 0 */
{ return recipineq11(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq21g(term t, term arg, term *next, char *reason)
 /* 1/x > a iff 0 < x < 1/a provided a > 0 */
{ return recipineq21(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq31g(term t, term arg, term *next, char *reason)
/* -a > 1/x iff -1/a < x < 0 provided a > 0 */
{ return recipineq31(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq41g(term t, term arg, term *next, char *reason)
/* 1/x > -a  iff x < -1/a or x > 0 provided a > 0 */
{ return recipineq41(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq12g(term t, term arg, term *next, char *reason)
/* a >= 1/x  iff x<0 or x >= 1/a provided a > 0 */
{ return recipineq12(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq22g(term t, term arg, term *next, char *reason)
/* 1/x >= a iff 0 < x  \le  1/a provided a > 0 */
{ return recipineq22(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq32g(term t, term arg, term *next, char *reason)
/* -a  \le  1/x iff -1/a  \le  x < 0 provided a > 0 */
{ return recipineq32(t,arg,next,reason);
}
/*_______________________________________________________________*/
int recipineq42g(term t, term arg, term *next, char *reason)
/* 1/x >= -a  iff x  \le  -1/a or x > 0 provided a > 0 */
{ return recipineq42(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squaretrue1g(term t, term arg, term *next, char *reason)
/* x^2 > a is true if a < 0      */
{ return squaretrue1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squarefalse1g(term t, term arg, term *next, char *reason)
/* a > x^2 is false if a <= 0    */
{ return squarefalse1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squaretrue2g(term t, term arg, term *next, char *reason)
/* x^2 >= a is true if a  \le  0      */
{ return squaretrue2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int squarefalse2g(term t, term arg, term *next, char *reason)
/* a >= x^2 is false if a < 0    */
{ return squarefalse2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int lnineq1g(term t, term arg, term *next, char *reason)
/* u > v iff ln u > ln v provided v>0   */
{ return lnineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int logineq1g(term t, term arg, term *next, char *reason)
/* u > v iff log u > log v provided v>0 */
{ return logineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int lnrightineq1g(term t, term arg, term *next, char *reason)
/* ln u > v iff u > e^v                 */
{ return lnrightineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int lnleftineq1g(term t, term arg, term *next, char *reason)
/* u > ln v iff e^u > v                 */
{ return lnleftineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int logrightineq1g(term t, term arg, term *next, char *reason)
{ return logrightineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int logleftineq1g(term t, term arg, term *next, char *reason)
/* u > log v iff 10^u > v               */
{ return logleftineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int expineq1g(term t, term arg, term *next, char *reason)
/* u > v iff a^u > a^v  if a > 0, takes arg in menu mode */
{ return expineq1(t,arg,next,reason);
}
/*_______________________________________________________________*/
int lnineq2g(term t, term arg, term *next, char *reason)
/* u >= v iff ln u >= ln v provided u>0   */
{ return lnineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int logineq2g(term t, term arg, term *next, char *reason)
/* u >= v => log u >= log v provided u>0  */
{ return logineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int lnrightineq2g(term t, term arg, term *next, char *reason)
/* ln u >= v iff u >= e^v                 */
{ return lnrightineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int lnleftineq2g(term t, term arg, term *next, char *reason)
/* u >= ln v iff e^u >= v                 */
{ return lnleftineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int logrightineq2g(term t, term arg, term *next, char *reason)
/* log u >= v iff u >= 10^v               */
{ return logrightineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int logleftineq2g(term t, term arg, term *next, char *reason)
/* u >= log v iff 10^u >= v               */
{ return logleftineq2(t,arg,next,reason);
}
/*_______________________________________________________________*/
int expineq2g(term t, term arg, term *next, char *reason)
/* u  \le  v iff a^u  \le  a^v  if a > 0, takes arg in menu mode */
{ return expineq2(t,arg,next,reason);
}