幂阶乘级数和解释

Question

问题:

设计了一个系列类，用于计算以下系列的总和：

类名：SeriesSum

数据成员/实例变量：

x：存储整数

n：存储术语数

sum：存储序列和的双变量

成员职能：

SeriesSum（int-xx，int-nn）：指定x=xx和n=nn的构造函数

使用递归技术返回΢的阶乘。

double findpower（int x， int y）： 使用递归技术将 x 提升为 y 的幂。

void calculate（）：通过分别调用递归函数来计算序列的和

空显示（）：显示序列的总和

（a） 指定类 SeriesSum，给出构造函数（int， int）、double findfact（int）、double findpower（int， int）、void calculate（ ） 和 void display（ ） 的详细信息。

定义 main（ ） 函数以创建对象，并相应地调用函数以启用任务。

代码：

class SeriesSum
    {
    int x,n;
    double sum;
    SeriesSum(int xx,int nn)
    { x=xx;
    n=nn;
    sum=0.0;
    }
    double findfact(int a)
    { return (a<2)? 1:a*findfact(a-1);
    }
    double findpower(int a, int b)
    { return (b==0)? 1:a*findpower(a,b-1);
    }
    void calculate()
    { for(int i=2;i<=n;i+=2)
    sum += findpower(x,i)/findfact(i-1);
    }
    void display()
    { System.out.println("sum="+ sum);
    }
    static void main()
    { SeriesSum obj = new SeriesSum(3,8);
    obj.calculate();
    obj.display();
    }
}

我的问题是：

我很难理解，当i=任意奇数时(以3为例)，那么通过findfact传递的值是(i-1)=2，那么我如何得到奇数阶乘，例如3！

任何帮助或指导都将不胜感激。

可选：

如果您能以某种方式解释findpower和FindFactory中发生的递归，这将非常有帮助。

Answer 1

你可以简化求和，去掉幂和阶乘。请注意：

1. 第一个术语就是x*x
2. 如果您知道术语＜code＞item==x**（2*n）/（2*n-1）下一个将是项*x*x/（2*n）/（2*n 1）

实施：

private static double sum(double x, int count) {
  double item = x * x; // First item
  double result = item;

  for (int i = 1; i <= count; ++i) {
    // Next item from previous
    item = item * x * x / (2 * i) / (2 * i +1);       

    result += item;   
  }

  return result;
}

在现实世界中，你可以注意到

sinh(x) = x/1! + x**3/3! + x**5/5! + ... + x**(2*n - 1) / (2*n - 1)! + ...

你的意甲只是

x * sinh(x) = x**2/1! + x**4 / 3! + ... + x**(2*n) / (2*n - 1)! + ...

所以你可以实现

private static double sum(double x) {
  return x * (Math.exp(x) - Math.exp(-x)) / 2.0;
}

Answer 2

尝试在代码下面运行，它会消除您所有的疑虑（我修改了一些访问说明符并创建了main方法）

public class SeriesSum
    {
    int x,n;
    double sum;
    SeriesSum(int xx,int nn)
    { x=xx;
    n=nn;
    sum=0.0;
    }
    double findfact(int a)
    { return (a<2)? 1:a*findfact(a-1);
    }
    double findpower(int a, int b)
    { return (b==0)? 1:a*findpower(a,b-1);
    }
    void calculate()
    { 
    System.out.println("x ="+x);    
    System.out.println("n ="+n);    
    for(int i=2;i<=n;i+=2){

        System.out.println(x+"^"+i+"/"+(i-1)+"!" +" = " +(findpower(x,i)+"/"+findfact(i-1)) );
        //System.out.println(findpower(x,i)+"/"+findfact(i-1));

        sum += findpower(x,i)/findfact(i-1);
    }
    }
    void display()
    { System.out.println("sum="+ sum);
    }
    public static void main(String arg[])
    { SeriesSum obj = new SeriesSum(3,8);
    obj.calculate();
    obj.display();
    }
}


// -----  output ----
    x =3
    n =8
    3^2/1! = 9.0/1.0
    3^4/3! = 81.0/6.0
    3^6/5! = 729.0/120.0
    3^8/7! = 6561.0/5040.0
    sum=29.876785714285713

Answer 3

仔细看看循环。i从2开始，每次迭代都增加2，所以它从来都不是奇数。它对应于x的连续幂，每个幂都被i-1的阶乘除以（这是奇数）。

至于＜code＞findfact＜/code＞中的递归，您只需手动展开前几个调用，即可了解其工作原理：

findfact(a) = a * findfact(a -1) 
    = a * (a - 1) * findfact(a -2)
    = a * (a - 1) * (a - 2) * findfact(a - 3)
    ...
    = a * (a - 1) * (a - 2) * ... * 2 * findfact(1)
    = a * (a - 1) * (a - 2) * ... * 2 * 1
    = a!*

同样的推理也适用于findpower。

作为旁注，尽管递归可能有助于教学，但对于计算阶乘或幂而言，递归是一个糟糕的想法。