介绍
 
项目中遇到给出几个间隔时间点的数据，然后判断其他时刻的数据，需要整体考虑数据的变化趋势，不能通过插值来得到中间未知时刻的数据，所以需要使用多项式拟合来将数据补全。
 
多项式函数是一个很重要的建模手段，利用任意个点，就可以拟合出一个多项式函数，通过多项式函数来推导出其他点的函数值，然后绘制出函数曲线，这个是最基本的原理！
 
拟合方法
 
通过点来拟合，得到拟合多项式的函数关系；
将得到的集合关系转化成多项式函数的表达式，形如xxx + axx + b*x +c 的样子；
将多项式函数表达式，解析成一个计算方法；
通过计算方法，来得到任意x（横坐标）对应的y（纵坐标）的值。
 
下面是用Java语言来实现多项式拟合的代码：
 
Java实现
 
拟合功能在下面代码中，已完整实现，可直接使用。
 
坐标实体类
 
定义坐标点的类，x（横坐标），y（纵坐标）
 
package cn.com.em.pu.fitting;

import java.io.Serializable;
import java.util.Objects;

/**
 * 坐标点
 *
 * @author pupengfei
 * @version 1.0
 * @date 2020/8/27 14:45
 */
public class Point implements Serializable {

    private static final long serialVersionUID = 3256087124347421878L;

    private double x;

    private double y;

    public Point() {
    }

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }


    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return Double.compare(point.x, x) == 0 &&
                Double.compare(point.y, y) == 0;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

 
自定义异常
 
package cn.com.em.pu.fitting;

/**
 * 多项式拟合异常
 *
 * @author pupengfei
 * @version 1.0
 * @date 2020/8/27 15:29
 */
public class PolynomialFittingException extends Exception {

    public PolynomialFittingException() {
    }

    public PolynomialFittingException(String message) {
        super(message);
    }

    public PolynomialFittingException(String message, Throwable cause) {
        super(message, cause);
    }
}

 
多项式计算公式接口
 
多项式计算公式，只有一个方法，根据x获取y的值
 
package cn.com.em.pu.fitting;

/**
 * 多项式计算公式，根据x获取y的值
 *
 * @author pupengfei
 * @version 1.0
 * @date 2020/8/27 13:57
 */
@FunctionalInterface
public interface PolynomialFnc {

    /**
     * 根据横坐标x，计算纵坐标y的值
     * @param x 横坐标
     * @return y，纵坐标
     */
    double getY(double x);

}

 
多项式拟合工具类
 
数据多项式拟合工具类
 
package cn.com.em.pu.fitting;

import java.util.ArrayList;
import java.util.List;

/**
 * 数据多项式拟合工具类
 *
 * @author pupengfei
 * @version 1.0
 * @date 2020/8/27 13:56
 */
public class PolynomialUtil {

    /**
     * 多项式拟合
     * @param data 坐标点集合
     * @return 多项式计算公式
     */
    public static PolynomialFnc fitting(List<Point> data) throws PolynomialFittingException {
        // 多项式每一项的计算表达式字符串
        List<String> returnResult = new ArrayList<>();

        int n = data.size();

        List<List<Double>> inputMatrix = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            List<Double> tempArr = new ArrayList<>();
            for (int j = 0; j < n; j++) {
                tempArr.add(Math.pow(data.get(i).getX(), n - j - 1));
            }

            tempArr.add(data.get(i).getY());
            inputMatrix.add(tempArr);
        }

        for (int i = 0; i < n; i++) {
            double base = inputMatrix.get(i).get(i);
            for (int j = 0; j < n + 1; j++) {
                if (base == 0) {
                    //存在相同x不同y的点，无法使用多项式进行拟合
                    throw new PolynomialFittingException("存在相同x不同y的点，无法使用多项式进行拟合");
                }
                inputMatrix.get(i).set(j, inputMatrix.get(i).get(j) / base);
            }
            for (int j = 0; j < n; j++) {
                if (i != j) {
                    double baseInner = inputMatrix.get(j).get(i);
                    for (int k = 0; k < n + 1; k++) {
                        inputMatrix.get(j).set(k, inputMatrix.get(j).get(k) - baseInner * inputMatrix.get(i).get(k));
                    }
                }
            }
        }
        for (int i = 0; i < n; i++) {
            if (inputMatrix.get(i).get(n) > 0) {
                returnResult.add("+");
            }

            if (inputMatrix.get(i).get(n) != 0) {
                String tmp_x = "";
                for (int j = 0; j < n - 1 - i; j++) {
                    tmp_x = tmp_x + "*x";
                }
                returnResult.add((inputMatrix.get(i).get(n) + tmp_x));
            }
        }

        // 将多项式表达式，转换为计算公式
        return x -> {
            double y = 0;
            for (String s : returnResult) {
                if ("+".equals(s)) {
                    y += 0;
                } else if (s.contains("*")) {
                    String[] split = s.split("\\*");
                    double temp = 1;
                    for (String s1 : split) {
                        if ("x".equals(s1)) {
                            temp *= x;
                        } else {
                            temp *= Double.parseDouble(s1);
                        }
                    }
                    y += temp;
                } else {
                    y += Double.parseDouble(s);
                }
            }

            return y;
        };
    }

}

 
演示代码
 
package cn.com.em.pu.fitting;

import java.util.ArrayList;
import java.util.List;

/**
 * 测试
 *
 * @author pupengfei
 * @version 1.0
 * @date 2020/8/27 20:18
 */
public class TestExample {

    public static void main(String[] args) throws PolynomialFittingException {
        List<Point> data = new ArrayList<>();
        data.add(new Point(1, 1));
        data.add(new Point(2, 2));
        data.add(new Point(3, 2));
        data.add(new Point(4, 1));
        PolynomialFnc fitting = PolynomialUtil.fitting(data);
        System.out.println(fitting.getY(3));

        data = new ArrayList<>();
        data.add(new Point(1, 1));
        data.add(new Point(2, 3));
        fitting = PolynomialUtil.fitting(data);
        System.out.println(fitting.getY(3));
    }

}

 
Jar包下载
 
下载地址

 
文章目录
 
多元多项式
**n** 元多项式概念
n元多项式
n元多项式环
$n$ 元多项式的字典排列法
    
有关性质
齐次多项式
$n$ 元多项式函数
   
对称多项式
一元多项式根与系数的关系
$n$ 元对称多项式
例1
例2 
          
           
            
             
            
            
             \quad
            
           
          
    
一 元多项式的判别式
例3
   
   
参考资料
 

 
多元多项式
 
n 元多项式概念
 
n元多项式
 
设 $\mathbf{P}$ 为一个数域, ${\mathbf{x}}_1,{\mathbf{x}}_2,\cdots ,{\mathbf{x}}_n$ 是 $\mathbf{n}$ 个文字, 形式
 $$a{x}_1^{k_1}{x}_2^{k_2}\cdots x_n^{k_n},a\in P,k_i\in Z^{+},i=1,2,\cdots ,n$$
 称为数域 $\mathbf{P}$ 上的一个单项式;
 
$a\ne 0$ 时，称此单项式中各文字的指数之和${\mathbf{k}}_1+{\mathbf{k}}_2+\cdots +{\mathbf{k}}_n$ 为这个单项式的次数 $;$
 
如果两单项式中相同文字的指数对应相等，则称它们为同类项;
 
有限个单项式的和
 $$f\left(x_1,x_2,\cdots ,x_n\right)=\sum _{k_1{k}_2\cdots k_n}{a}_{k_1{k}_2\cdots k_n}{x}_1^{k_1}{x}_2^{k_2}\cdots x_n^{k_n}$$
 称为数域 $\mathbf{P}$ 上的一个 $n$ 元多项式。
 
$n$ 元多项式中系数不为零的单项式的最高次数称为这个多项式的次数.
 
n元多项式环
 
数域 $P$ 上关于文字 $x_1,x_2,\cdots ,x_n$ 的全体 $n$ 元多项式的集合称为数域 $\mathbf{P}$ 上的 $n$ 元多项式环，记作
 
$$P\left[x_1,x_2,\cdots ,x_n\right]$$
 
$n$ 元多项式的字典排列法
 
任取n元多项式
 $$f\left(x_1,x_2,\cdots ,x_n\right)=\sum _{k_1{k}_2\cdots k_n}{a}_{k_1{k}_2\cdots k_n}{x}_1^{k_1}{x}_2^{k_2}\cdots x_n^{k_n}\text{\hspace{1em}(1)}$$
 中的两个单项式
 $$\mathbf{a}{\mathbf{x}}_1^{k_1}{\mathbf{x}}_2^{k_2}\cdots {\mathbf{x}}_n^{k_n},\mathbf{b}{\mathbf{x}}_1^{l_1}{\mathbf{x}}_2^{l_2}\cdots {\mathbf{x}}_n^{l_n}$$
 若有某个 $1\le i\le n,$ 使
 $$k_1-l_1=k_2-l_2=\cdots =k_{i-1}-l_{i-1}=0,k_i-l_i>0$$
 （此时也称数组 $\left(k_1,k_2,\cdots ,k_n\right)$ 先于 $\left(l_1,l_2,\cdots ,l_n\right),$ 记作
 $$\left(k_1,k_2,\cdots ,k_n\right)>\left(l_1,l_2,\cdots ,l_n\right)$$
 则在多项式（1）中，把单项式 $a{x}_1^{k_1}{x}_2^{k_2}\cdots x_n^{k_n}$ 写在$b{x}_1^{l_1}{x}_2^{l_2}\cdots x_n^{l_n}$ 的前面. 将n元多项式中各单项式按这种先后次序排列的方法称为字典排列法.
 
当n=1时，字典排列法即为降幕排列法.
 
按字典排列法写出的第一个系数不为零的单项式称为多项式的首项.
 
$注意：$
 多元多项式的首项未是最高次项.例如,
 $$\begin{array}{l}\begin{array}{rl}f\left(x_1,x_2,x_3\right)& =2x_1{x}_2^2{x}_3^2+x_1^2{x}_2+x_1^3\\ =& x_1^3+x_1^2{x}_2+2x_1{x}_2^2{x}_3^2\end{array}\end{array}$$
 $f$ 的次数为5， 首项为 $x_1^3.$
 
有关性质
 
$\boxed{定理}$当 $f\left(x_1,\cdots ,x_n\right)\ne 0,g\left(x_1,\cdots ,x_n\right)\ne 0$ 时,积 $f\left(x_1,\cdots ,x_n\right)g\left(x_1,\cdots ,x_n\right)$ 的首项等于 $f\left(x_1,\cdots ,x_n\right)$的首项与 $g\left(x_1,\cdots ,x_n\right)$ 的首项的积.
 
$\boxed{推论1}$ 若 $f_i\left(x_1,\cdots ,x_n\right)\ne 0,i=1,2,\cdots ,m,$ 则积$f_1{f}_2\cdots f_m$ 的首项等于 $f_1,f_2,\cdots ,f_m$ 的首项的积.
 
$\boxed{推论2}$ 若 $f\left(x_1,\cdots ,x_n\right)\ne 0,g\left(x_1,\cdots ,x_n\right)\ne 0,$ 则$f\left(x_1,\cdots ,x_n\right)g\left(x_1,\cdots ,x_n\right)\ne 0$
 
齐次多项式
 
$\boxed{定义}$
    
     
      
       
      
      
       \quad
      
     
     若多项式
 $$f\left(x_1,x_2,\cdots ,x_n\right)=\sum _{k_1,k_2\cdots k_n}{a}_{k_1,k_2\cdots k_n}{x}_1^{k_1}{x}_2^{k_2}\cdots x_n^{k_n}$$
 中每个单项式全是m次的，则称 $f\left(x_1,x_2,\cdots ,x_n\right)$为m次齐次多项式.
 
性质
 
 
两个齐次多项式的积仍然是齐次多项式;积的次数等于这两个齐次多项式的次数之和.
 
 
任一 $\mathbf{m}$ 次多项式 $\mathbf{f}\left(x_1,\cdots ,{\mathbf{x}}_{\mathbf{n}}\right)$ 都可唯一地表成
 $$f\left(x_1,\cdots ,x_n\right)=\sum _{i=1}^m{f}_i\left(x_1,\cdots ,x_n\right)$$
 其中 $f_i\left(x_1,\cdots ,x_n\right)$ 是 $i$ 次齐次多项式，称之为$f\left(x_1,\cdots ,x_n\right)$ 的 $i$ 次齐次成分.
 
 
设 $f\left(x_1,\cdots ,x_n\right)={\sum }_{i=1}^m{f}_i\left(x_1,\cdots ,x_n\right)$
 $$g\left(x_1,\cdots ,x_n\right)=\sum _{i=1}^l{g}_i\left(x_1,\cdots ,x_n\right)$$
 则积 $h\left(x_1,\cdots ,x_n\right)=f\left(x_1,\cdots ,x_n\right)g\left(x_1,\cdots ,x_n\right)$的 $k$ 次齐次成分为
 $$h_k\left(x_1,\cdots ,x_n\right)=\sum _{i+j=k}{f}_i\left(x_1,\cdots ,x_n\right)g_j\left(x_1,\cdots ,x_n\right)$$
 特别地， ${\mathbf{h}}_{m+l}\left(x_1,\cdots ,x_n\right)=f_m\left(x_1,\cdots ,x_n\right)g_l\left(x_1,\cdots ,x_n\right)$
 
 
积的次数=因子的次数之和.
 
 
$n$ 元多项式函数
 
与一元多项式一样我们可以定义n元多项式函数、函数值等概念.
 
对称多项式
 
一元多项式根与系数的关系
 
$\boxed{韦达定理}$ 设
 $$f(x)=x^n+a_1{x}^{n-1}+a_2{x}^{n-2}+\cdots +a_n\in P[x]\text{\hspace{1em}(2)}$$
 
若 $f(x)$ 在 $P$ 上有 $n$ 个根 ${\alpha }_1,{\alpha }_2,\cdots ,{\alpha }_n$ 则
 $$f(x)=\left(x-{\alpha }_1\right)\left(x-{\alpha }_2\right)\cdots \left(x-{\alpha }_n\right)\text{\hspace{1em}(3)}$$
 把(3)展开，与(2)比较，即得根与系数的关系:
 $$\{\begin{array}{l}-a_1={\alpha }_1+{\alpha }_2+\cdots +{\alpha }_n\\ a_2={\alpha }_1{\alpha }_2+{\alpha }_1{\alpha }_3+\cdots +{\alpha }_{n-1}{\alpha }_n\\ \cdots \cdots \cdots \cdots \cdots \cdots \cdots \cdots \\ (-1{)}^i{a}_i=\sum {\alpha }_{k_1}{\alpha }_{k_2}\cdots {\alpha }_{k_i}\left(\text{ 所有可能的 }i\text{ 个不同的 }{a}_{k_j}\text{ 的积之和 }\right)\\ \cdots \cdots \cdots \cdots \cdots \cdots \cdots \\ (-1{)}^n{a}_n={\alpha }_1{\alpha }_2\cdots {\alpha }_n\end{array}$$
 特别地 $a{x}^2+bx+c=0(a\ne 0),x_1,x_2$ 为其根
 则有 $x_1+x_2=-\frac{b}{a},x_1{x}_2=\frac{c}{a}$
 
$n$ 元对称多项式
 
$\boxed{定义}$
    
     
      
       
      
      
       \quad
      
     
     设 $f\left(x_1,\cdots ,x_n\right)\in P\left[x_1,x_2,\cdots ,x_n\right]$,若对任意 $i,\mathbf{j}(1\le i,j\le n)$ 有
 $$f\left(x_1,\cdots ,x_i,\cdots ,x_j,\cdots ,x_n\right)=f\left(x_1,\cdots ,x_j,\cdots ,x_i,\cdots ,x_n\right)$$
 则称该多项式为对称多项式.
 
如, $f\left(x_1,x_2,x_3\right)=x_1^3+x_2^3+x_3^3$
 
下列n个多项式
 $$\{\begin{array}{ll}& {\sigma }_1=x_1+x_2+\cdots +x_n\\ & {\sigma }_2=x_1{x}_2+x_1{x}_3+\cdots +x_{n-1}{x}_n\\ & {\sigma }_n=x_1{x}_2\cdots x_n\end{array}$$
 称为 $n$ 个未定元 $x_1,x_2,\cdots ,x_n$ 的初等对称多项式.
 
$\boxed{性质}$
 
对称多项式的和、积仍是对称多项式;对称多项式的多项式仍为对称多项式. 即，若 $f_1,f_2,\cdots ,f_m\in P\left[x_1,x_2,\cdots ,x_n\right]$ 为对称多项式,$g\left(y_1,y_2,\cdots ,y_m\right)$ 为任一多项式, 
     
      
       
        
       
       
        \quad
       
      
      则
 
$$g\left(f_1,f_2,\cdots ,f_m\right)=h\left(x_1,x_2,\cdots ,x_n\right)$$
 
是 $n$ 元对称多项式.
 
特别地，初等对称多项式的多项式仍为对称多项式.
 
对称多项式基本定理
 
对任一对称多项式 $f\left(x_1,\cdots ,x_n\right),$ 都有 $n$ 元多项式$\phi \left(y_1,y_2,\cdots ,y_n\right),$ 使得
 $$f\left(x_1,\cdots ,x_n\right)=\phi \left({\sigma }_1,{\sigma }_2,\cdots ,{\sigma }_n\right)$$
 ${\sigma }_1,{\sigma }_2,\cdots ,{\sigma }_n$ 为初等对称多项式.
 
【证明】: 设对称多项式 $f\left(x_1,\cdots ,x_n\right)$ 按字典排列法的首项为 $a{x}_1^{l_1}{x}_2^{l_2}\cdots x_n^{l_n},$ 则必有
 $$l_1\ge l_2\ge \cdots \ge l_n\ge 0$$
 作对称多项式 ${\phi }_1=a{\sigma }_1^{l_1-l_2}{\sigma }_2^{l_2-l_3}\cdots {\sigma }_n^{l_n}$ 。
 
则 ${\phi }_1$ 的首项为
 $$a{x}_1^{l_1-l_2}{\left(x_1{x}_2\right)}^{l_2-l_3}\cdots {\left(x_1{x}_2\cdots x_n\right)}^{l_n}=a{x}_1^{l_1}{x}_2^{l_2}\cdots x_n^{l_n}$$
 再作对称多项式
 $$f_1=f-{\phi }_1=f\left(x_1,\cdots ,x_n\right)-a{x}_1^{l_1}{x}_2^{l_2}\cdots x_n^{l_n}-\cdots$$
 则 $f_1$ 有比 $f$ 较“小”的首项.对 $f_1$ 重复上述作法，并依此下去.即有一系列对称多项式
 $$f,f_1=f-{\phi }_1,f_2=f_1-{\phi }_2,\cdots \cdots$$
 它们的首项一个比一个“小”，所以必终此在有限步.故存在 $h\in Z^{+}$ 使 $f_h=f_{h-1}-{\phi }_h=0$
 于是 $f={\phi }_1+{\phi }_2+\cdots +{\phi }_h$，这就是一个初等对称多项式的多项式.
 
$说明$
 
上述证明过程实际上是逐步消去首项.逐步消去首项法的一般步骤:
 
第一步：找出对称多项式 $f$ 的首项 $a{x}_1^{l_1}{x}_2^{l_2}\cdots x_n^{l_n},$确定它对应的指数组 $\left(l_1,l_2,\cdots ,l_n\right),$ 则一定有
 $$l_1\ge l_2\ge \cdots \ge l_n$$
 第二步：由 $f$ 的首项写出 ${\phi }_1$ :
 $${\phi }_1=a{\sigma }_1^{l_1-l_2}{\sigma }_2^{l_2-l_3}\cdots {\sigma }_n^{l_n}$$
 第三步: 作 $f_1=f-{\phi }_1,$ 并展开化简.再对 $f_1$ 按一、二、三步骤进行，构造 $f_2$ :
 $$\begin{array}{c}{f}_2=f_1-{\phi }_2\\ ⋮\end{array}$$
 如此反复进行，直到出现 $f_h=f_{h-1}-{\phi }_h=0,$ 则
 $$f={\phi }_1+{\phi }_2+\cdots +{\phi }_h$$
 
例1
 
把多项式 $\mathbf{f}$ 表成初等对称多项式的多项式,
 $$f=x_1^3+x_2^3+x_3^3$$
 解: $f$ 的首项是 $x_1^3,$ 它所对应的数组是 $(3,0,0),$
 $$\text{ 令 }{\phi }_1={\sigma }_1^{3-0}{\sigma }_2^{0-0}{\sigma }_3^0={\sigma }_1^3$$
 作对称多项式 $f_1$ :
 $$\begin{array}{l}{f}_1=f-{\phi }_1=x_1^3+x_2^3+x_3^3-{\sigma }_1^3\\ =-3\left(x_1^2{x}_2+x_2^2{x}_1+x_1^2{x}_3+x_3^2{x}_1+x_2^2{x}_3+x_3^2{x}_2\right)-6x_1{x}_2{x}_3\end{array}$$
 $f_1$ 的首项是 $-3x_1^2{x}_2,$ 它所对应的指数组是 $(2,1,0),$ 令
 $$\begin{array}{l}\begin{array}{rl}{\phi }_2& =-3{\sigma }_1^{2-1}{\sigma }_2^{1-0}{\sigma }_3^0=-3{\sigma }_1{\sigma }_2\\ & =-3\left(x_1+x_2+x_3\right)\left(x_1{x}_2+x_1{x}_3+x_2{x}_3\right)\\ =& -3\left(x_1^2{x}_2+x_2^2{x}_1+x_1^2{x}_3+x_3^2{x}_1+x_2^2{x}_3+x_3^2{x}_2\right)-9x_1{x}_2{x}_3\end{array}\end{array}$$
 作对称多项式 $f_2=f_1-{\phi }_2=3x_1{x}_2{x}_3$ ，令 ${\phi }_3=3{\sigma }_1^{1-1}{\sigma }_2^{1-1}{\sigma }_3^{1-0}=3{\sigma }_3$ 。
 于是 $f_3=f_2-{\phi }_3=0$
 所以, $f={\phi }_1+{\phi }_2+{\phi }_3={\sigma }_1^3-3{\sigma }_1{\sigma }_2+3{\sigma }_3$
 
$附：$
 
对于齐次对称多项式还可以采用待定系数法.待定系数法的一般步骤:(设 $f$ 是m次齐次对称多项式)
 
第一步：根据对称多项式 $f$ 首项对应的指数组写出所有可能的指数组 $\left(k_1,k_2,\cdots ,k_n\right)$ 且这些指数组满足 :
 (1) $k_1\ge k_2\ge \cdots \ge k_n$
 (2) $k_1+k_2+\cdots +k_n=m$
 (3) 前面的指数组先于后面的指数组.
 
第二步: 对每个指数组 $\left(k_1,k_2,\cdots ,k_n\right),$ 写出它对应的初等对称多项式的方幕的乘积:
 $${\sigma }_1^{k_1-k_2}{\sigma }_2^{k_2-k_3}\cdots {\sigma }_n^{k_n}$$
 第三步：设出 $f$ 由所有初等对称多项式的方幕乘积的线性表达式，其首项系数即为 $f$ 的首项系数，其余各项系数分别用A、B、C、… 代替.
 
第四步：分组选取适当的 $x_i(i=1,2,\cdots ,n)$ 的值，计算出 ${\sigma }_1,{\sigma }_2,\cdots ,{\sigma }_n$ 及 $f$,将之代入第三步中设出的线性表达式中，得到关于A、B、C、… 的线性方程组，解这个线性方程组求得A、B、C、… 的值.最后写出所求的 $f$ 的表达式.
 
例2 
    
     
      
       
      
      
       \quad
      
     
    
 
用待定系数法把 $f=x_1^3+x_2^3+x_3^3$ 表成初等对称多项式的多项式.
 
解: $f$ 的首项是 $x_1^3,$ 它所对应的数组是 $(3,0,0),$所有不先于 (3,0,0)的三次指数组及相应的初等对称多项式方幕的乘积如下表:
 
指数组
相应的初等对称多项式方幕的乘积
$(3,0,0)$
${\sigma }_1^{3-0}{\sigma }_2^{0-0}{\sigma }_3^0={\sigma }_1^3$
$(2,1,0)$
${\sigma }_1^{2-1}{\sigma }_2^{1-0}{\sigma }_3^0={\sigma }_1{\sigma }_2$
$(1,1,1)$
${\sigma }_1^{1-1}{\sigma }_2^{1-1}{\sigma }_3^1={\sigma }_3$
这样， $f$ 可表成
 $$f={\sigma }_1^3+A{\sigma }_1{\sigma }_2+B{\sigma }_3\text{\hspace{1em}(5)}$$
 
适当选取 $x_i(i=1,2,3)$ 的值，计算出 ${\sigma }_1,{\sigma }_2,\cdots ,{\sigma }_n$ 及 $f$ 的值如下表:
 
${\mathbf{x}}_1$
${\mathbf{x}}_2$
${\mathbf{x}}_3$
${\sigma }_1$
${\sigma }_2$
${\sigma }_3$
$\mathbf{f}$
1
1
1
3
3
1
3
1
1
0
2
1
0
2
代入 (5) 式得 $\{\begin{array}{c}27+9A+B=3\\ 8+2A=2\end{array}$
 解之得 $A=-3,B=3$,所以 $f={\sigma }_1^3-3{\sigma }_1{\sigma }_2+3{\sigma }_3$
 
一 元多项式的判别式
 
对称多项式
 $$D\left(x_1,\cdots ,x_n\right)=\prod _{1\le i<j\le n}{\left(x_i-x_j\right)}^2$$
 有特殊的重要性. 按对称多项式基本定理知，D可表成 ${\sigma }_1=-a_1,{\sigma }_2=(-1{)}^2{a}_2,\cdots ,{\sigma }_n=(-1{)}^n{a}_n$的多项式 $D\left(a_1,\cdots ,a_n\right).$ 由根与系数的关系知，$x_1,\cdots ,x_n$ 是
 $$f(x)=x^n+a_1{x}^{n-1}+a_2{x}^{n-2}+\cdots +a_n\text{\hspace{1em}(6)}$$
 的根，则多项（6）有重根的充要条件是
 $$D\left(a_1,\cdots ,a_n\right)=0$$
 正因为此, $D\left(a_1,\cdots ,a_n\right)=0$称为多项式(6)的判别式
 
例3
 
求 $f(x)=x^2+a_{1}x+a_2$ 的判别式.
 $$\begin{array}{rl}D=& {\left(x_1-x_2\right)}^2=x_1^2-2x_1{x}_2+x_2^2\\ & ={\left(x_1+x_2\right)}^2-4x_1{x}_2\\ & ={\sigma }_1^2-4{\sigma }_2=a_1^2-4a_2\end{array}$$
 
参考资料
 
高等代数 厦门大学
 
高等代数，林亚南，高等教育出版社
 
《高等代数》（第四版） 高等教育出版社
 
高等代数 电子科技大学
 
高等代数_安阳师范学院
 
《高等代数》（第五版）

　　一个复杂的多项式可以“过拟合”任意数据，言外之意是多项式函数可以接近于任何函数，这是什么道理呢？
 
 
泰勒公式
 
　　欲理解多项式函数的过拟合，必先理解泰勒公式。
 
　　泰勒公式是一种计算近似值的方法，它是一个用函数某点的信息描述在该点附近取值的公式。已知函数在某一点的各阶导数值的情况之下，泰勒公式可以用这些导数值做系数构建一个多项式来逼近函数在这一点的邻域中的值。
 
　　如果f(x)在x0处具有任意阶导数，那么泰勒公式是这样的：
 
 
　　上式中的幂级数称为f(x)在x0点的泰勒级数。（0的阶乘是1）
 
  　 更多泰勒公式的介绍可参考  单变量微积分笔记31——幂级数和泰勒级数
 
 
 
泰勒公式的应用
 
　　来看一个泰勒公式的应用。假设一个小偷盗取了一辆汽车，他在高速公路上沿着一个方向行驶，车辆的位移s是关于时间t的函数。警方接到报案后马上调取监控，得知在零点（t=0时刻）小偷距车辆丢失地点的位移是s0。现在的时间是0:30，警方想要在前方设卡，从而能在凌晨1点拦住小偷，应该在哪里设卡呢？
 
　　我们知道车辆在0点时的位移是s0，现在想要知道凌晨1点时车辆的位置：
 
 
　　可以直接使用泰勒公式：
 
 
　　泰勒公式可以无限展开，展开得越多，越逼近真实值，并且越到后面的项，对结果的影响越小，我们认为0和1非常接近，所以只展开到2阶导数：
 
 
　　这就是最终结果，在此处设卡最有可能在第一时间拦住小偷。
 
在0点处的泰勒展开
 
　　在使用泰勒公式时，经常取x0=0。
 
 
　　f(x)=ex是一个可以用泰勒公式展开的例子，下面是ex在x0=0处的泰勒展开：
 
 
　　当x=1时，还附带得到了e的解释：
 
 
　　我们使用一个很难处理的积分解释泰勒展开的意义，对正态分布进行积分：
 
 
　　常规的方法很难处理。现在，由于被积函数与ex相似，我们又已经知道ex的展开式，所以可以进行下面的变换：
 
 
　　将exp(-x2)左右两侧同时积分：
 
 
　　很容易计算右侧的每一项积分。
 
　　这个例子展示了幂级数展开的意义——把质的困难转化成量的复杂。展开前求解函数的值很困难，展开后是幂级数，虽然有很多很多项，但是每一项都是幂函数，都很容易求解，于是，只要对展开后的函数求和，就能得到展开前的函数的值。
 
为什么在0点处展开
 
　　当x0=0时，可以极大地简化泰勒展开式。之前说泰勒公式是一个用函数某点的信息描述在该点附近取值的公式，一个函数中的某点如果距离0很远怎么办呢？实际上泰勒公式也能够逼近函数在距离0很远处的取值，只不过此时只展开到2阶导数是不够的，需要展开很多项，展开的越多，越能逼近该点。以标准正态分布函数f(x)=exp(-x2)为例，虽然它在二阶展开使与原函数相差较大，但是当展开到40阶时就已经非常接近原函数了。
 
 
多项式函数
 
　　理解了泰勒公式后，再回到问题的原点，看看多项式函数为什么可以接近于任何函数。
 
　　仍然以标准正态分布为例，它在x0 = 0点处的10阶泰勒展开是：
 
 
　　如果将每一项中的xi都看作一个维度，那么这个多项式函数可以写成多元线性回归的形式：
 
 
　　这就将一个一元的非线性问题转换成了多元的线性问题，从而利用最小二乘法求得模型参数。
 
　　下面的代码以ln(2x) + 2为原函数，生成40个在-1~1之间随机震荡的数据点，并使用线性回归和多项式回归拟合数据点：
 
 
 
import numpy as np
import matplotlib.pyplot as plt

def create_datas():
    '''
    生成10个待拟合的点
    :return: xs, ys
    '''
    xs = np.arange(0.1, 4, 0.1)
    # y = ln(2x) + noize,  -1 <= noize <= 1
    ys = np.array([np.log(x * 2) + 2 + np.random.uniform(-1, 1) for x in xs])

    return xs, ys

class Regression():
    ''' 回归类 '''
    def __init__(self, xs, ys):
        '''
        :param xs: 输入数据的特征集合
        :param ys: 输入数据的标签集合
        '''
        self.xs, self.ys = xs, ys
        self.theta = None # 模型参数

    def train_datas(self, xs=None):
        '''
        重新构造训练样本的特征和标签
        :param xs: 输入数据的特征集合
        :return: 矩阵形式的训练样本特征和标签
        '''
        xs = self.xs if xs is None else xs
        X = self.train_datas_x(xs)
        Y = np.c_[ys] # 将ys转换为m行1列的矩阵
        return X, Y

    def train_datas_x(self, xs):
        '''
        重新构造训练样本的特征
        :param xs: 输入数据的特征集合
        :return: 矩阵形式的训练样本特征
        '''
        m = len(xs)
        # 在第一列添加x0,x0=1,并将二维列表转换为矩阵
        X = np.mat(np.c_[np.ones(m), xs])
        return X

    def fit(self):
        ''' 数据拟合 '''
        X, Y = self.train_datas()
        self.theta = (X.T * X).I * X.T * Y

    def predict(self, xs):
        '''
        根据模型预测结果
        :param xs: 输入数据的特征集合
        :return: 预测结果
        '''
        X = self.train_datas(xs=xs)[0]
        return self.theta.T * X.T

    def show(self):
        ''' 绘制拟合结果 '''
        plt.figure()
        plt.scatter(self.xs, self.ys, color='r', marker='.', s=10)  # 绘制数据点
        self.show_curve(plt) # 绘制函数曲线
        plt.xlabel('x')
        plt.ylabel('y')
        plt.axis('equal')
        plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
        plt.rcParams['axes.unicode_minus'] = False  # 解决中文下的坐标轴负号显示问题
        plt.legend(['拟合曲线', '样本点'])
        plt.show()

    def show_curve(self, plt):
        ''' 绘制函数曲线 '''
        pass

    def global_fun(self):
        ''' 返回目标函数 '''
        gf = ['(' + str(t[0, 0]) + str(i) + ')x^' + str(i) for i, t in enumerate(self.theta)]
        return ' + '.join(gf)

class Linear(Regression):
    ''' 线性模型'''
    def show_curve(self, plt):
        '''
        绘制拟合结果
        :param plt: 输入数据的特征集合
        '''
        xx = [self.xs[0], self.xs[-1]]
        yy = self.predict(xx)
        plt.plot(xx, np.array(yy)[0])

class Multinomial(Regression):
    ''' 多项式回归模型 '''
    def __init__(self, xs, ys, n=3):
        '''
        :param xs: 输入数据的特征集合
        :param ys: 输入数据的标签集合
        :param n: 多项式的项数
        '''
        super().__init__(xs, ys)
        self.n = n

    def train_datas_x(self, xs):
        '''
        重新构造训练样本的特征
        :param xs: 输入数据的特征集合
        :return: 矩阵形式的训练样本特征
        '''
        X = super().train_datas_x(xs)
        for i in range(2, self.n + 1):
            X = np.column_stack((X, np.c_[xs ** i])) # 构造样本的其他特征
        return X

    def show_curve(self, plt):
        ''' 绘制函数曲线 '''
        xx = np.linspace(self.xs[0], self.xs[-1], len(self.xs) * 20)
        yy = self.predict(xx)
        plt.plot(xx, np.array(yy)[0], '-')

if __name__ == '__main__':
    xs, ys = create_datas()
    regressions = [Linear(xs, ys), Multinomial(xs, ys), Multinomial(xs, ys, n=5), Multinomial(xs, ys, n=10)]
    for r in regressions:
        r.fit()
        r.show()
        print(r.global_fun())
 
 
(1.702537204930)x^0 + (0.75431357262260011)x^1
 
 
 
 (0.23422131704216660)x^0 + (3.8713793437217621)x^1 + (-1.51749485964066682)x^2 + (0.206815637166500283)x^3
 
 
 (0.0023811193415048670)x^0 + (4.707160334405161)x^1 + (-2.03334533257402762)x^2 + (0.095635349482284143)x^3 + (0.130611330518000564)x^4 + (-0.021122013844903465)x^5
 
 
(-4.7285135624557920)x^0 + (77.637488456533421)x^1 + (-377.238590224254552)x^2 + (932.32693158635363)x^3
 
+ (-1305.30725871564164)x^4 + (1112.9257341435945)x^5 + (-598.57958115210336)x^6
 
+ (203.91275172701427)x^7 + (-42.641981259587898)x^8 + (4.9915417588645349)x^9 + (-0.250300601937088710)x^10
 
 　　看来第二、三条曲线的拟合效果比较好，第一幅图欠拟合，四过拟合。
 

　　作者：我是8位的
 
　　出处：http://www.cnblogs.com/bigmonkey
 
　　本文以学习、研究和分享为主，如需转载，请联系本人，标明作者和出处，非商业用途！ 
 
　　扫描二维码关注公作者众号“我是8位的”
 

2.2 多项式函数 
 
看其他篇章到目录 选择。 
 
在 Commons Math中的 analysis.polynomials包中有所有的与多项式函数相关的类和接口定义。这一篇主要从这个包分析，来研究一下多项式函数的应用。 
 
 
   
Polynomials包中没有 interface的定义，下属含有 5个类： PolynomialFunction、 PolynomialFunctionLagrangeForm、 PolynomialFunctionNewtonForm、 PolynomialSplineFunction和 PolynomialsUtils。其中主要的只有 PolynomialFunction和 PolynomialSplineFunction，正如 api doc中的介绍， PolynomialFunction类是 Immutable representation of a real polynomial function with real coefficients——实数多项式的表示； PolynomialSplineFunction类是 Represents a polynomial spline function.——样条曲线多项式的表示。另外两个表示拉格朗日和牛顿形式的多项式函数。而 PolynomialsUtils类中提供了几个构造个别（比如切比雪夫多项式）多项式的静态方法。 
 
我觉得最常用的应该就是实数系数的多项式了，因此以 PolynomialFunction类为例来进行分析。实数系数的多项式函数形如： f(x) = ax^2 + bx + c。 PolynomialFunction类实现了 DifferentiableUnivariateRealFunction接口，因此必须实现 value()和 derivative()方法，并且实现该接口也表明这是一元可微分的实数函数形式。 PolynomialFunction类定义了一组 final double coefficients[]作为多项式系数，其中 coefficients[0]表示常数项的系数， coefficients[n]表示指数为 n的 x^n次项的系数。因此，这个类所表达的多项式函数是这样的： f(x)=coeff[0] + coeff[1]x + coeff[2]x^2 + … + coeff[n]x^n。它的构造方法是 PolynomialFunction(double [])就是接受这样的 coefficients数组作为系数输入参数来构造多项式的。这个是很好表达也很方便理解的。那么它的 value(double x)方法是通过调用 double evaluate(double [] coefficients, double argument)实现的，本质用 Horner's Method求解多项式的值，没有什么技术难点，非常好理解的一个给定参数和函数求值过程。剩余定义的一些加减乘等操作，都是通过一个类似public  PolynomialFunction add(final PolynomialFunction p)这样的结构实现的。求导数的方法 derivative()是通过这样的一个微分操作实现的。见源码： 
 
 
   
 
  1 
 
 
 protected 
   
 static 
   
 double 
 [] differentiate( 
 double 
 [] coefficients)  
  
 {
  2           int  n  =  coefficients.length;
  3           if  (n  <   1 )   {
  4               throw  MathRuntimeException.createIllegalArgumentException( " empty polynomials coefficients array " );
  5          }  
  6           if  (n  ==   1 )   {
  7               return   new   double []  { 0 }  ;
  8          }  
  9           double [] result  =   new   double [n  -   1 ];
 10           for  ( int  i  =  n  -   1 ; i   >   0 ; i -- )   {
 11              result[i  -   1 ]  =  i  *  coefficients[i];
 12          }  
 13           return  result;
 14      }  
 
 
 15 
  
   
测试代码示例如下：
 
 
 
 
  1 
 
 
 /** */ 
 /** 
  2   * 
  3    */  
 
 
  4 
  
 package 
  algorithm.math;
 
  5 
 
 
  6 
  
 import 
  org.apache.commons.math.ArgumentOutsideDomainException;
 
  7 
  
 import 
  org.apache.commons.math.analysis.polynomials.PolynomialFunction;
 
  8 
  
 import 
  org.apache.commons.math.analysis.polynomials.PolynomialSplineFunction;
 
  9 
 
 
 10 
  
 /** */ 
 /** 
 11   *  @author  Jia Yu
 12   * @date 2010-11-21
 13    */  
 
 
 14 
  
 public 
   
 class 
  PolinomialsFunctionTest  
  
 {
 15 
 16       /** */ /** 
 17       *  @param  args
 18        */  
 19       public   static   void  main(String[] args)   {
 20           //  TODO Auto-generated method stub 
 21          polynomials();
 22          System.out.println( " ----------------------------------------------- " );
 23          polynomialsSpline();
 24      }  
 25 
 26       private   static   void  polynomialsSpline()   {
 27           //  TODO Auto-generated method stub 
 28          PolynomialFunction[] polynomials  =    {
 29                   new  PolynomialFunction( new   double []   { 0d, 1d, 1d }  ),
 30                   new  PolynomialFunction( new   double []   { 2d, 1d, 1d }  ),
 31                   new  PolynomialFunction( new   double []   { 4d, 1d, 1d }  ) }  ;
 32           double [] knots  =    {  - 1 ,  0 ,  1 ,  2  }  ;
 33          PolynomialSplineFunction spline  =   new  PolynomialSplineFunction(knots,
 34                  polynomials);
 35           // output directly 
 36          System.out.println( " poly spline func is  " + spline);
 37           //  get the value when x = 0.5 
 38           try    {
 39              System.out.println( " f(0.5) =  " + spline.value( 0.5 ));
 40          }    catch  (ArgumentOutsideDomainException e)   {
 41               //  TODO Auto-generated catch block 
 42              e.printStackTrace();
 43          }  
 44           //  the number of spline segments 
 45          System.out.println( " spline segments number is  " + spline.getN());
 46           //  the polynomials functions 
 47           for ( int  i = 0 ;i < spline.getN();i ++ )  {
 48              System.out.println( " spline:f " + i + " (x) =  " + spline.getPolynomials()[i]);
 49          }  
 50           // function derivative 
 51          System.out.println( " spline func derivative is  " + spline.derivative());
 52      }  
 53 
 54       private   static   void  polynomials()   {
 55           //  TODO Auto-generated method stub 
 56           double [] f1_coeff  =    {  3.0 ,  6.0 ,  - 2.0 ,  1.0  }  ;
 57           double [] f2_coeff  =    {  1.0 ,  2.0 ,  - 1.0 ,  - 2.0  }  ;
 58          PolynomialFunction f1  =   new  PolynomialFunction(f1_coeff);
 59          PolynomialFunction f2  =   new  PolynomialFunction(f2_coeff);
 60           //  output directly 
 61          System.out.println( " f1(x) is :  "   +  f1);
 62          System.out.println( " f2(x) is :  "   +  f2);
 63           //  polynomial degree 
 64          System.out.println( " f1(x)'s degree is  "   +  f1.degree());
 65           //  get the value when x = 2 
 66          System.out.println( " f1(2) =  "   +  f1.value( 2 ));
 67           //  function add 
 68          System.out.println( " f1(x)+f2(x) =  "   +  f1.add(f2));
 69           //  function substract 
 70          System.out.println( " f1(x)-f2(x) =  "   +  f1.subtract(f2));
 71           //  function multiply 
 72          System.out.println( " f1(x)*f2(x) =  "   +  f1.multiply(f2));
 73           //  function derivative 
 74          System.out.println( " f1'(x) =  "   +  f1.derivative());
 75          System.out.println( " f2''(x) =  " 
 76                   +  ((PolynomialFunction) f2.derivative()).derivative());
 77 
 78      }  
 79 
 80  }  
 
 
 81 
  
 
 
 输出如下：
 f1(x) is : 3.0 + 6.0 x - 2.0 x^2 + x^3
 f2(x) is : 1.0 + 2.0 x - x^2 - 2.0 x^3
 f1(x)'s degree is 3
 f1(2) = 15.0
 f1(x)+f2(x) = 4.0 + 8.0 x - 3.0 x^2 - x^3
 f1(x)-f2(x) = 2.0 + 4.0 x - x^2 + 3.0 x^3
 f1(x)*f2(x) = 3.0 + 12.0 x + 7.0 x^2 - 15.0 x^3 - 8.0 x^4 + 3.0 x^5 - 2.0 x^6
 f1'(x) = 6.0 - 4.0 x + 3.0 x^2
 f2''(x) = -2.0 - 12.0 x
 -----------------------------------------------
 poly spline func is org.apache.commons.math.analysis.polynomials.PolynomialSplineFunction@69b332
 f(0.5) = 2.75
 spline segments number is 3
 spline:f0(x) = x + x^2
 spline:f1(x) = 2.0 + x + x^2
 spline:f2(x) = 4.0 + x + x^2
 spline func derivative is org.apache.commons.math.analysis.polynomials.PolynomialSplineFunction@173a10f
 
PolynomialFunction类也是重写了 toString方法和 hashCode和 equals方法的。 
 
PolynomialSplineFunction类是多项式样条函数，样条 是一种特殊的函数，由多项式分段定义。表示了一个由多个多项式组成的样条曲线。它的实现主要是内部定义了一个多项式函数组 PolynomialFunction polynomials[]和一个样条分界节点数组 double knots[]。这两个内部成员分别表示什么呢？分界节点表示整条曲线对应在 x等于 knots[i]的时候开始使用其他多项式样条，其构造方法 public PolynomialSplineFunction(double knots[], PolynomialFunction polynomials[])完成这样的功能。 
 
举例来说，一个多项式样条函数就是一个分段函数： 
 
      X^2+x    [-1,0)
 
F(x) = x^2+x+2   [0,1)
 
      X^2+x+4 [1,2)
 
当然，构造方法中的参数， knots[]数组必须是递增的。
 
 可以看到，直接输出 PolynomialSplineFunction是多么丑陋啊 ~~，因为它没有重写 toString方法。同样，它的导数也是一样的丑陋。其中如果给定的值不在定义域内， value方法还抛出异常 ArgumentOutsideDomainException。 
 
最后 PolynomialFunctionLagrangeForm和 PolynomialFunctionNewtonForm类完成的其实是多项式插值的功能，放到下一节研究的。 
 
相关资料： 
 
多项式： http://zh.wikipedia.org/zh-cn/%E5%A4%9A%E9%A1%B9%E5%BC%8F%E5%87%BD%E6%95%B0#.E5.A4.9A.E9.A0.85.E5.BC.8F.E5.87.BD.E6.95.B8.E5.8F.8A.E5.A4.9A.E9.A0.85.E5.BC.8F.E7.9A.84.E6.A0.B9 
 
样条函数： http://zh.wikipedia.org/zh-cn/%E6%A0%B7%E6%9D%A1%E5%87%BD%E6%95%B0 
 
Horner Methods： http://mathworld.wolfram.com/HornersMethod.html 
 
Commons math包： http://commons.apache.org/math/index.html