values.cpp

来自「数据结构与程序设计教材源码 数据结构与程序设计教材源码」· C++ 代码 · 共 238 行

double trunc(const double &v)
{
   double ans;
   if (v >= 0.0)
      ans = (double) ((int) v);
   else
      ans = - ((double) ((int) (-v)));
   return ans;
}
 
double round(const double &v)
{
   if (v >= 0.0) return (double) ((int) (v + 0.5));
   else return -round(-v);
}
 
double factorial(const double &v)
{
   double temp = v;
   double ans = temp;
   while (temp >= 2.0) {
      temp = temp - 1.0;
      ans *= temp;
   }
   while (temp <= 0.0) {
      temp = temp + 1.0;
      ans *= temp;
   }
   return ans;
}
 
double percent(const double &v)
{
   double ans;
   ans = v / 100.0;
   return ans;
}
 
double cos(const double &v)
{
   double ans = 1.0;
   double temp = v*v;
   double ct = 3.0;
   double mult = -temp/2.0;
   while (mult > 0.00001 || mult < -0.00001) {
     ans += mult;
     mult *= temp;
     mult /= ct;
     ct = ct + 1;
     mult /= ct;
     ct = ct + 1;
     mult = -mult;
   }
   return ans;
}
 
double sin(const double &v)
{
   double ans = 0.0;
   double temp = v;
   double ct = 1.0;
   double mult = temp;
   while (mult > 0.00001 || mult < -0.00001) {
     ans += mult;
     ct = ct + 1;
     mult *= temp;
     mult /= ct;
     ct = ct + 1;
     mult *= temp;
     mult /= ct;
     mult = -mult;
   }
   return ans;
}
 
double arctan(const double &v)
{
   double ans = 0.0;
   bool negative= false;
   double temp = v;
   if (v < 0) {
      negative= true;
      temp = -v;
   }
   bool recip = false;
   if (temp > 1.0) {
     recip = true;
     temp = 1.0/temp;
   }

   double ct = 1.0;
   double mult = temp;
   temp = temp * temp;
   double sign = 1.0;
   while (mult > 0.00001) {
     ans += sign*mult/ct;
     ct = ct + 2;
     sign = -sign;
     mult *= temp;
   }

   if (recip) {
      ans = 3.141592/ 2.0 - ans;
   }
   if (negative) {
      ans = - ans;
   }
   return ans;
}
 
double ln(const double &v)
{
   double ans = 0.0;
   double temp = v;
   if (temp <= 0.0) return 0.0;
   while (temp < 0.99999) {
      ans -= 1.0;
      temp *= 2.71828;
   }
   while (temp > 2.71829) {
      ans += 1.0;
      temp /=2.71828;
   }
   bool recip = false;
   if (2.71828/temp < temp) {
      temp = 2.71828/temp;
      recip = true;
   }
   temp = temp - 1.0;
   double ct = 1.0;
   double addon = 0.0;
   double mult = temp;
   double sign = 1.0;
   while (mult > 0.00001) {
     addon += sign*mult/ct;
     ct = ct + 1;
     sign = -sign;
     mult *= temp;
   }
   if (recip) addon = 1.0 - addon;
   ans = ans + addon;
   return ans;
}
 
double expo(const double &v)
{
   double ans = 1.0;
   double temp = v;
   double ct = 1.0;
   double mult = temp;
   while (mult > 0.00001 || mult < -0.00001) {
     ans += mult;
     ct = ct + 1;
     mult *= temp;
     mult /= ct;
   }
   return ans;
}
 
double exp(const double &v, const double &w)
{
   return expo(ln(v) * w);
}
 
Value get_value(const Token &current)
/* 
 
Pre:  Token current is an operand.
Post: The Value of current is returned.
Uses: Methods of class Token.
 
*/
{
   return current.value();
}
 
Value do_unary(Token &t, Value &v)
{
   switch (t.code_number()) {
   case 3:
      return -v;
   case 4:
      if (v < 0) return -v;
      else return v;
   case 5:
      return v*v;
   case 6:
      return exp(v, 0.5);
   case 7:
      return exp(2.71828, v);
   case 8:
      return ln(v);
   case 9:
      return ln(v)/ln(10);
   case 10:
      return sin(v);
   case 11:
      return cos(v);
   case 12:
      return arctan(v);
   case 13:
      return round(v);
   case 14:
      return trunc(v);
   case 15:
      return factorial(v);
   case 16:
      return percent(v);
   }
   return v;
}
 
Value do_binary(const Token &operation,
                const Value &first_argument, const Value &second_argument)
/* 
 
Pre:  Token operation is a binary operator.
Post: The Value of operation applied to the pair
      of Value parameters is returned.
Uses: Methods of class Token.
 
*/
{
   switch (operation.code_number()) {
   case 17:
      return first_argument + second_argument;
   case 18:
      return first_argument - second_argument;
   case 19:
      return first_argument * second_argument;
   case 20:
      return first_argument / second_argument;
   case 21:
      return exp(first_argument, second_argument);
   }
   return first_argument;
}