Real function can be represented by a series of Taylor, the radius of the convergence of which is determined by the position of the singular points of the function. Any final segment of the Taylor series is a polynomial, so it can be calculated using addition and multiplication operations.

The program calculates the ln (1-x) function. Help please remake calculations in the code for the exp (x ^ 2 function .

# include & lt; stdio.h & gt;
#Include & lt; stdlib.h & gt;
#Include & lt; math.h & gt;
// This Function Is Calculating The Power Of X
Double Powx (Double X, Int i)
{
  Switch (I)
  {
    Case 0:
      Return 1;
    Case 1:
      Return x;
    Default:
      RETURN X * POWX (X, I - 1);
  }
}
// This Function Is Calculating The Value Of A Member of the Serie
Double Membvalcalc (Double X, Int i)
{
  RETURN -1 * (POWX (X, I) / I);
}
INT MAIN ()
{
  / * ACC = accuracy; result = aproximated value; ET_Result = Contain Library Value;
    AprDiff = Is The Difference Between Library's Value and The Result of this Program's Work * /
  Double X, ACC, Result, Membval, Et_result, AprDiff, Achievedacc;
  int i, j = 0,
      n; // N - IS The Maximal Member of Serie In The Calculation
  PrintF ("This Program Will Calculate Function LN (1-X). \ n");
  Printf ("Please, Enter X Value Between -1.0 and 1.0 AS 'Double' Type:");
  ScanF ("% LF", & amp; x);
  // Area of ​​Definition of this Function; IF X NOT Belong To This Area, The Program Will Be Closed
  if ((X & LT; -0.9999999) || (X & GT; 0.9999999))
  {
    PrintF ("Error: X Must Be The Value Between -1 and 1. \ n");
    Return -1;
  }
  Printf ("Please, Enter N Value As 'Integer' Type:");
  Scanf ("% d", & amp; n);
  Printf ("Enter Accuracy of Calculation AS 'Double' Type:");
  Scanf ("% LF", & amp; ACC);
  If (ACC & LT; 0)
  {
    PrintF ("Error: Accuracy Is Negative Number.");
    Return -1;
  }
  RESULT = 0.0;
  // This for Loop Is Calculating Each Member of The Serie and Increase The Result Variable by This Value
  for (i = 1; i & lt; = n; i ++)
  {
    Membval = Membvalcalc (X, I);
    j = i;
    if ((Membval & gt; 0) & amp; & amp; (Membval & lt; = ACC))
    {
      j = i - 1;
      Break;
    }
    ELSE If ((Membval & LT; 0) & amp; & amp; ((Membval * -1) & lt; = ACC))
    {
      j = i - 1;
      Break;
    }
    ELSE.
    {
      Result + = Membval;
    }
  }
  ET_RESULT = log (1 - x);
  if (result & gt; = 0) & amp; & amp; (et_result & gt; = 0))
  {
    APRDIFF = RESULT - ET_RESULT;
  }
  ELSE if ((Result & lt; 0) & amp; & amp; (et_result & lt; 0))
  {
    APRDIFF = (result * -1) - (et_result * -1);
  }
  ELSE.
  {
    APRDIFF = RESULT + ET_RESULT;
  }
  Achievedacc = Membvalcalc (x, j);
  if (APRDIFF & LT; 0)
  {
    APRDIFF * = -1;
  }
  if (Achievedacc & lt; 0)
  {
    Achievedacc * = -1;
  }
  PrintF ("Total Quantity of Calculated Members of the Serie:% D \ N", j);
  Printf ("The Achieved Accuracy of Calculation IS% F \ N", Achievedacc);
  PrintF ("The result log (1-x) is:% LF \ N", Result);
  Printf ("Using the Math.h Library We Could Get The Result Log =% LF \ N"
      et_result);
  Printf ("The Difference Between Calculated Approximation and Library's Value:% LF",
      APRDIFF);
  Return 0;
}

Answer 1, Authority 100%

in general, insert where you need – here is a function that believes exp (x ^ 2) with the accuracy EPS decomposition in a Taylor series:

double expx2 (double x, double eps)
{
  Double Sum = 1.0, Term = 1.0;
  x = x * x;
  For (int n = 1; Term & gt; eps; ++ n)
  {
    SUM + = TERM * = X / N;
  }
  Return Sum;
}