Sindbad~EG File Manager

/*
limit of quotients of roots menu operators for MathXpert
M. Beeson
7.14.93 original date
2.27.98 last modified
2.9.05  modified includes
12.12.23 eliminated OEM characters
*/
#include <string.h>
#include <assert.h>

#include "globals.h"
#include "calc.h"
#include "prover.h"
#include "order.h"
#include "checkarg.h"
#include "algaux.h"
#include "mplimits.h"
#include "graphstr.h"
#include "mpdoc.h"
#include "automode.h"  /* setlocus */
#include "symbols.h"
#include "errbuf.h"
#include "pathtail.h"
#include "ops.h"
#include "autosimp.h"

/*__________________________________________________________*/
int limsqrt1(term t, term arg, term *next, char *reason)
/* sqrt a/b = sqrt (a/b^2) if b>0 inside a limit */
/* t must be a limit term */
{ term num,b,a,newlimitand,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  num = ARG(0,u);
  b = ARG(1,u);
  if(FUNCTOR(num) != SQRT)
     return 1;
  a = ARG(0,num);
  err = infer(positive(b));
  if(err)
     { errbuf(0,english(871));
           /* Can't prove denominator is positive. */
       return 1;
     }
  newlimitand = make_sqrt(make_fraction(a, make_power(b,two)));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? limit(ARG(0,t),newlimitand) : limit3(ARG(0,t),ARG(1,t),newlimitand);
  strcpy(reason, english(2171));  /* $ sqrt a/b = sqrt (a/b^2)$ if b>0 */
  SetShowStepOperation(sqrtnum);
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  return 0;
}

/*__________________________________________________________*/
int limsqrt2(term t, term arg, term *next, char *reason)
/* sqrt a/b = - sqrt(a/b^2) if b \le 0 inside a limit */
/* t must be a limit term */
{ term num,b,a,newlimitand,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  num = ARG(0,u);
  b = ARG(1,u);
  if(FUNCTOR(num) != SQRT)
     return 1;
  a = ARG(0,num);
  err = infer(negative(b));
  if(err)
     { errbuf(0,english(872));
           /* Can't prove denominator is negative. */
       return 1;
     }
  newlimitand = make_sqrt(make_fraction(a, make_power(b,two)));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? tnegate(limit(ARG(0,t),newlimitand)) : tnegate(limit3(ARG(0,t),ARG(1,t),newlimitand));
  strcpy(reason, english(2172)); /* sqrt a/b= -sqrt (a/b^2) if b<0 */
  SetShowStepOperation(sqrtnum);
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  return 0;
}

/*__________________________________________________________*/
int limroot1(term t, term arg, term *next, char *reason)
/* root(n,a)/b = root(n,(a/b^n) if b \ge 0 0 or n is odd, inside a limit */
/* t must be a limit term */
{ term num,b,a,newlimitand,n,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  num = ARG(0,u);
  b = ARG(1,u);
  if(FUNCTOR(num) != ROOT)
     return 1;
  a = ARG(1,num);
  n = ARG(0,num);
  err = infer(odd(n));
  if(err)
     { err = infer(positive(b));
       if(err)
          { errbuf(0, english(876));
            /* Index of root must be odd, or denominator positive. */
            return 1;
          }
     }
  newlimitand = make_root(n, make_fraction(a, make_power(b,n)));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? limit(ARG(0,t),newlimitand) : limit3(ARG(0,t),ARG(1,t),newlimitand);
  strcpy(reason, "$(\\supn\\sqrt a)/b = \\supn\\sqrt(a/b^n)$      ");
  strcat(reason, english(2173));   /* (b>0 or n odd) */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(rootnum);
  return 0;
}

/*__________________________________________________________*/
int limroot2(term t, term arg, term *next, char *reason)
/* root(n,a)/b = -root(n,a/b^n) if b<0 and n is even, inside a limit */
/* t must be a limit term */
{ term num,b,a,newlimitand,n,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  num = ARG(0,u);
  b = ARG(1,u);
  if(FUNCTOR(num) != ROOT)
     return 1;
  a = ARG(1,num);
  n = ARG(0,num);
  err = infer(negative(b));
  if(err)
     { errbuf(0,english(872));
           /* Can't prove denominator is negative. */
       return 1;
     }
  err = infer(even(n));
  if(err)
     { errbuf(0,english(875));
           /* Index of root must be even. */
       return 1;
     }
  newlimitand = make_root(n,make_fraction(a, make_power(b,n)));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? tnegate(limit(ARG(0,t),newlimitand)) : tnegate(limit3(ARG(0,t),ARG(1,t),newlimitand));
  strcpy(reason, "$root(n,a)/b = -\\supn\\sqrt(a/b^n)$      ");
  strcat(reason, english(2174));  /* (b<0, n even) */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(rootnum);
  return 0;
}

/*__________________________________________________________*/
int limsqrtdenom1(term t, term arg, term *next, char *reason)
/* a/ sqrt b = sqrt (a^2/b) if a \ge 0 inside a limit */
/* t must be a limit term */
{ term denom,b,a,newlimitand,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  a = ARG(0,u);
  denom = ARG(1,u);
  if(FUNCTOR(denom) != SQRT)
     return 1;
  b = ARG(0,denom);
  err = infer(le(zero,a));
  if(err)
     { errbuf(0,english(873));
        /* Can't prove numerator is \ge 0. */
       return 1;
     }
  newlimitand = make_sqrt(make_fraction(make_power(a,two),b));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? limit(ARG(0,t),newlimitand) : limit3(ARG(0,t),ARG(1,t),newlimitand);
  strcpy(reason, "$a/\\sqrt b = \\sqrt(a^2/b)$ ");
  strcat(reason, english(2175));   /*  if a \ge 0 */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(sqrtdenom);
  return 0;
}

/*__________________________________________________________*/
int limsqrtdenom2(term t, term arg, term *next, char *reason)
/* a/\\sqrt b = -\\sqrt (a^2/b) if a\\le 0 inside a limit */
/* t must be a limit term */
{ term denom,b,a,newlimitand,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  a = ARG(0,u);
  denom = ARG(1,u);
  if(FUNCTOR(denom) != SQRT)
     return 1;
  b = ARG(0,denom);
   /* We must tell the theorem-prover what the locus of the bound variable is */
  err = infer(le(a,zero));
  if(err)
     { errbuf(0,english(874));
        /* Can't prove numerator is $\\le 0$. */
       return 1;
     }
  newlimitand = make_sqrt(make_fraction(make_power(a,two),b));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? tnegate(limit(ARG(0,t),newlimitand)) : tnegate(limit3(ARG(0,t),ARG(1,t),newlimitand));
  strcpy(reason, "$a/\\sqrt b= -\\sqrt(a^2/b)$ ");
  strcat(reason, english(2176));  /* if a\\le 0 */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(sqrtdenom);
  return 0;
}

/*__________________________________________________________*/
int limrootdenom1(term t, term arg, term *next, char *reason)
/* a/root(n,b) =root(n,a^n/b) if a \ge 0 or n is odd, inside a limit */
/* t must be a limit term */
{ term denom,b,a,n,newlimitand,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  a = ARG(0,u);
  denom = ARG(1,u);
  if(FUNCTOR(denom) != ROOT)
     return 1;
  b = ARG(1,denom);
  n = ARG(0,denom);
  err = infer(odd(n));
  if(err)
     { err = infer(le(zero,a));
       if(err)
          { errbuf(0, english(877));
            /* Index of root must be odd, or numerator \ge 0. */
            return 1;
          }
     }
  newlimitand = make_root(n,make_fraction(make_power(a,n),b));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? limit(ARG(0,t),newlimitand) : limit3(ARG(0,t),ARG(1,t),newlimitand);
  strcpy(reason, "$a/\\supn\\sqrt b = \\supn \\sqrt(a^n/b)$       ");
  strcat(reason, english(2177));  /* (n odd or a\\ge 0) */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(rootdenom);
  return 0;
}
/*__________________________________________________________*/
int limrootdenom2(term t, term arg, term *next, char *reason)
/* a/root(n,b) = -root(n,a^n/b) if a\ge 0 and n is even, inside a limit */
/* t must be a limit term */
{ term denom,b,a,n,newlimitand,u;
  int err;
  unsigned short path[5];
  if(FUNCTOR(t) != LIMIT)
     return 1;
  u = LIMITAND(t);
  if(!FRACTION(u))
     return 1;
  a = ARG(0,u);
  denom = ARG(1,u);
  if(FUNCTOR(denom) != ROOT)
     return 1;
  b = ARG(1,denom);
  n = ARG(0,denom);
  err = infer(even(n));
  if(err)
     { errbuf(0,english(875));
          /* Index of root must be even */
       return 1;
     }
  err = infer(le(a,zero));
  if(err)
     { errbuf(0, english(874));
       /* Can't prove numerator is \ge 0 */
       return 1;
     }
  newlimitand = make_root(n,make_fraction(make_power(a,n),b));
  HIGHLIGHT(newlimitand);
  *next = ARITY(t)==2 ? tnegate(limit(ARG(0,t),newlimitand)) : tnegate(limit3(ARG(0,t),ARG(1,t),newlimitand));
  strcpy(reason, "$a/\\supn\\sqrt = -\\supn\\sqrt(a^n/b)$      ");
  strcat(reason, english(2178));   /* (n even and a \ge 0) */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(rootdenom);
  return 0;
}