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
*/
#include <string.h>
#include <assert.h>
#define TRIGCALC_DLL
#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 "document.h"
#include "automode.h"  /* setlocus */
#include "symbols.h"
#include "errbuf.h"
#include "pathtail.h"
#include "ops.h"
#include "autosimp.h"

/*__________________________________________________________*/
MEXPORT_TRIGCALC int limsqrt1(term t, term arg, term *next, char *reason)
/* �a/b = �(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));  /* $�a/b = �(a/b^2)$ if b>0 */
  SetShowStepOperation(sqrtnum);
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  return 0;
}

/*__________________________________________________________*/
MEXPORT_TRIGCALC int limsqrt2(term t, term arg, term *next, char *reason)
/* �a/b = -�(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(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)); /* �a/b= -�(a/b^2) if b<0 */
  SetShowStepOperation(sqrtnum);
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  return 0;
}

/*__________________________________________________________*/
MEXPORT_TRIGCALC int limroot1(term t, term arg, term *next, char *reason)
/* ��a/b = ��(a/b�) if b�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, "$��a/b = ��(a/b�)$      ");
  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;
}

/*__________________________________________________________*/
MEXPORT_TRIGCALC int limroot2(term t, term arg, term *next, char *reason)
/* ��a/b = -�(a/b�) 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, "$��a/b = -��(a/b�)$      ");
  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;
}

/*__________________________________________________________*/
MEXPORT_TRIGCALC int limsqrtdenom1(term t, term arg, term *next, char *reason)
/* a/�b = �(a^2/b) if a�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 � 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/�b = �(a^2/b)$ ");
  strcat(reason, english(2175));   /*  if a�0 */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(sqrtdenom);
  return 0;
}

/*__________________________________________________________*/
MEXPORT_TRIGCALC int limsqrtdenom2(term t, term arg, term *next, char *reason)
/* a/�b = -�(a^2/b) if a�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 � 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/�b= -�(a^2/b)$ ");
  strcat(reason, english(2176));  /* if a�0 */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(sqrtdenom);
  return 0;
}

/*__________________________________________________________*/
MEXPORT_TRIGCALC int limrootdenom1(term t, term arg, term *next, char *reason)
/* a/��b = �(a�/b) if a�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 � 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/��b = ��(a�/b)$       ");
  strcat(reason, english(2177));  /* (n odd or a�0) */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(rootdenom);
  return 0;
}
/*__________________________________________________________*/
MEXPORT_TRIGCALC int limrootdenom2(term t, term arg, term *next, char *reason)
/* a/��b = -�(a�/b) if a�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 � 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/��b = -��(a�/b)$      ");
  strcat(reason, english(2178));   /* (n even and a�0) */
  path[0] = LIMIT;
  path[1] = ARITY(t);
  path[2] = 0;
  set_pathtail(path);
  SetShowStepOperation(rootdenom);
  return 0;
}