polynomial,高分 C++数据结构，一元多项式的相乘-知识分享-234导航

polynomial,高分 C++数据结构，一元多项式的相乘详细介绍

本文目录一览：多项式的英语翻译多项式用英语怎么说

polymerization ，有“聚合；多项式”的意思
多项式
[数] polynomial；[数] multinomial；quantic；[数] Polyomial更多释义>>

[网络短语]

多项式 Polynomial;polynomial;multiple-term formula
对称多项式 Symmetric polynomial;symmetric polynomial;symmetric polynominal
HOMFLY多项式 HOMFLY polynomial;HOMFLYPT polynomial;HOMFLY

怎么理解 P 问题和 NP 问题？

P：polynominal，多项式求值。P问题：存在多项式时间算法的问题
P问题是判定问题类题目,此类问题可以用一种确定性算法在多项式时间内判定或解出。如果一个复杂的判定性问题是此问题的多项式函数，那我们就将可以在多项式时间内解决的判定性问题归位P类问题。P类问题就是复杂度为多项式时间的问题的总成集合。
P是一个判断问题类，它可以用多项式时间的确定性算法来确定或求解。如果一个给定的定性问题的复杂性问题的一个实例的大小n多项式函数,我们说这可以在多项式时间内解决定性问题的P 类问题是所有问题的多项式时间。
NP:Nondeterministic polynominal，非确定性多项式求值。NP问题；能在多项式时间内验证得出一个正确解的问题。
然而，有些问题很难找到一个多项式时间算法，但是我们发现如果你给我们一个问题的答案，我们可以在多项式时间里判断答案是否正确。在多项式时间内验证解是否正确的问题称为NP。显然，所有P类问题都是NP问题，但问题是，P是否等于NP?这个问题还没有解决。
显然，所有P问题都是NP问题。也就是说，要解决一个问题的多项式，可以肯定多项式来验证一个问题的解，因为真理出来了，也只需要比较任何给定解的验证。
以上为两者之间联系与区别。
其实用大白话解释P和NP就是P就是能在多项式时间内解决的问题，NP就是能在多项式时间验证答案正确与否的问题。
而关于这两个我也不是很明白按照专业术语来说应该就是：P类的定义，确定性 Turing Machine（简单来说其实就是定义了一个算法）在多项式时间内可解决的判定问题。具体不再赘述。BTW，Chomsky Hierarchy 真的是个老古董了。。。下面的东西不太严谨，不过我尝试给出一些相对直觉的理解。
NP的话，也不见得非要引入非确定性Turing Machine。举个例子。想象一下，你和你导师在讨论某个东西的证明。你的导师是个学界大牛，而你只是个水平一般的高年级本科生。那么如何分析你这时候的理解能力呢？有老师带的时候学习能力真的会变强嘛？
而对于NP来讲 NP也有很多种
X为NP hard，进一步如果X是NP的，称X是NP complete的。而事实上，的确所有的NP问题都可以规约到某一些NP问题，这类问题也就是经常出现的NP complete问题，比如TSP（旅行商）问题。
一般情况下非判定问题都可以转化为多项式时间次数的判定问题，所以P和NP的计算复杂度概念可以适用于几乎所有算法问题。现在可以知道，由于所有的NP问题都可以多项式规约到某一个NP Complete问题，所以只要一个NP Complete问题能在多项式时间内得到解决，那么所有的NP问题都可以在多项式时间内得到结局了。目前常见的计算机问题几乎都是NP的（多项式时间内能验证结果，大部分算法问题都满足），也就是说，如果能多项式解决某一个NP Complete问题，几乎所有的算法问题都能在多项式解决了。

英语不好，有时候是因为数学不好

记得在看《公主日记》系列第一本的时候，就被里面的algebra（代数）整得晕头转向。什么integer（整数）,distributive law（分配律）, slope（斜率）, coefficient（系数）啦，polynominal（多项式）啦，……有些词光查简单的释义根本解决不了问题，还得认真看一下详细的英文释义才能勉强搞懂，比查别的单词更要费时间。
作为一个数学白痴，我不得不承认，英语水平也被因此拖了后腿。
再举几个例子。
学过数学的人至少知道一些简单的希腊字母，比如delta，大写形式是个“△”，所以delta又是“三角洲”的意思。The Nile Delta就是“尼罗河三角洲”的意思。Deltoid是“三角肌”，deltoiditis是“三角肌炎”。
再比如iota，大写为“Ι”，小写是“ι”，而iota在英语里就是“极少量，一点儿” 的意思。
还有omega，因为是24个希腊字母最后一个，所以from alpha to omega 就是“从头到尾”的意思。
而希腊字母表里第一个字母alpha和第二个字母beta的组合，就是字母表alphabet了。
是不是有种恍然大悟的感觉？
那好，今天且让语文老师来给你们上一堂阔别已久的数学课。
先来看看最常见的数学符号对应的英语名称。
是不是并没有你想象的那么难呢？
其实，数学相关的词虽然还有很多，但记忆起来并没有那么可怕。因为你可以以简单词为基础，结合一些有效的记忆方法，拓展自己的词汇量。
————@ 主题记忆法 @————
也就是在同一个主题下记忆单词。比如和加减乘除运算有关的词等等。
add 加 addend 加数，addition 加法，summand 被加数，sum 和
subtract 减 subtranend 减数，subtraction 减法，minus 减，minuend 被减数，difference 差
multiply 乘 multiplier 乘数，multiplicand 被乘数，multiplicationg 乘法，product 乘积，biproduct 双乘积，subproduct 子积
divide 除 divisor 除数，dividend 被除数，division 除法，quotient 商，subquotient 子商
angle 角 arc 弧，base 底，chord 弦，circle 圆，edge 棱，ellipse 椭圆，line 线，point 点，prism 棱柱，side 边，sphere 球，surface 面
axis 轴 major axis 长轴，minor axis 短轴，conjugate axis 共轭轴，principal axis 主轴，transverse axis 横截轴
fraction 分数 vulgar fraction，common fraction 普通分数，simple fraction 简分数， complex fraction 繁分数，numerator 分子，denominator 分母，(least)common denominator (最小)公分母，quarter 四分之一
————@ 同义词记忆法 @————
同一个意思，不同的表达方式，也需要我们了解。
————@ 反义相对记忆法 @————
通过对比加强记忆，事半功倍。
————@ 词根词缀记忆法 @————
认识一个词，就相当于认识了许多。相当划得来的一种记忆方法。不要被那些长词吓到。掌握了规律，拆分开来看就一点不难了。
center 中心 barycenter 重心，excenter 外心，hypercenter 超中心，incenter 内心， orthocenter 垂心
circle 圆 bicircle 双圆，circumcircle 外接圆，excircle 外圆，incircle 内切圆，point-cirle 点圆，semi-circle 半圆
cycle 圆；周期；循环 epicycle 周转圆，half-cycle 半周期，hypercycle 超循环，othocycle 正交圆
gon 角；边 trigon 三角形，tetragon 四角形；四边形，pentagon 五角形；五边形，hexagon 六角形；六边形，heptagon 七角形；七边形，octagon 八角形；八边形，enneagon 九角形；九边形，decagon 十角形；十边形，undecagon 十一角形；十一边形，dodecagon 十二角形；十二边形，polygon 多角形；多边形，n-sided polygon N边形，regular n-sided polygon 正N边形
hedron ……面体 dihedron 二面体，trihedron 三面体，tetrahedron 四面体，pentahedron 五面体，hexahedron 六面体，tetrahexahedron 四六面体，heptahedron 七面体，octahedron 八面体，enneahedron 九面体，decahedron 是免提，undecahedron 十一面体，dodecahedron 十二面体，tetrakaidecahedron 十四面体，icosahedron 二十面体，polyhedron 多面体
nomial ……项式 monomial 单项式，binomial 二项式，trinomial 三项式，quardrinominal 四项式，polynomial 多项式，infrapolynomial 内多项式
metry 测量 Anti-symmetry 反对称性，centrosymmetry 中心对称，cyclosymmetry 循环对称，semi-symmetry 半对称，dissymmetry 不对称
geometry 几何学 analytic geometry 解析几何，plane geometry 平面几何，solid geometry 立体几何，goniometry 测角术，isometry 等距，trigonometry 三角学
————@ 追根究底法 @————
一些词光靠死记硬背是远远不够的。只有明白具体的数学计算，才不会忘记。就拿distributive law来说吧。如果你不能真正理解，那么你就很难搞定GRE的数学题。
推荐查看纯英文的解释，只有既能记住单词，也能get到一些数学方面的句子表述。
看懂了吗？如果觉得不过瘾，还可以尝试阅读一些原版数学读物，给数学彻底来个大复习。
基础差的可以读读Mathematics Readers（美国数学分级读物），跟着5-12岁的美国本土孩子一块学一遍基础数学。
数学学霸们可以读如A Computational Introduction To Number Theory And Algebra（数字理论和代数计算导论），Abstract Algebra（抽象代数），Classical differential geometry of curves and surfaces（经典曲线和曲面微分几何学）等等更加高大上的数学书籍。
当然，这是针对学有余力的童鞋说的。如果你不是数学专业的，平时也用不到太多数学词汇，掌握基本的就已经够用。平时的英文阅读也不会受到太大影响。
总之，不用被这些面目可憎的数学词汇吓倒。掌握了科学的方法，就能轻松攻克它们。

c++ 多项式类用链表的实现

#include

while (p)

{

sum += p->coef * pow(x, p->exp);

p = p->next;

}

return sum;

}

void CPolynominal::Copy(const CPolynominal &a)

{ //复制对象(公用函数)

Node *t,*s,*p;

p=a.head;s=head=0;

while(p)

{

t=new Node;

if (head==0) head=t;

t->coef=p->coef;

t->exp=p->exp;

p=p->next;

if(s) s->next=t;

s=t;

}

if (s) s->next=0;

}

CPolynominal::CPolynominal(const CPolynominal& a)//复制构造函数

{

Copy(a);

}

void CPolynominal::Create(double *c,int *e,int n)//创建多项式

{

if (n<1)

cout<<"错误：要创建多项式的项数必须大于零。\n";

else

{

head=new Node;//创建头结点

head->coef=c[0];

head->exp=e[0];

Node *q,*p=head;

for (int i=1;i
<n;i++)
{

q=new Node;

q->coef=c[i];

q->exp=e[i];

p->next=q;

p=q;

}

p->next=0;

}

}

Node* CPolynominal::get(int e)//读取指数为e的项

{

Node *p=head;

while (p)

{

if (p->exp==e) return p;

p=p->next;

}

return p;//没有找到，返回空指针

}

void CPolynominal::set(double c,int e)

{//将指数为e系数为c的项加入多项式(原多项式无指数为e的项)

Node *q,*p,*t;

t=new Node;

t->coef=c;

t->exp=e;

if (head==0)

{

head=t;

head->next=0;

return;

}

if (e>head->exp)

{

t->next=head;

head=t;//插入头部

return;

}

p=head;

while (p && e

exp)

{

q=p;

p=p->next;

}

if (p)

{

//新的项插入p所指结点前

t->next=p;

q->next=t;

}

else//插入尾部

{

q->next=t;

t->next=0;

}

}

CPolynominal operator +(CPolynominal a,CPolynominal b)//重载+运算符

{

CPolynominal temp;

Node *p,*q,*s,*t;

double x;

s=new Node;temp.head=s;//先增加一个头结点

p=a.head;

q=b.head;

while (p && q)

{

if (p->exp==q->exp)

{

x=p->coef+q->coef;

if (x!=0.0)

{

t=new Node;

t->exp=p->exp;

t->coef=x;

s->next=t;

s=t;

}

p=p->next;

q=q->next;

}

else

{

t=new Node;

if(p->exp>q->exp)

{

t->coef=p->coef;

t->exp=p->exp;

p=p->next;

}

else

{

t->coef=q->coef;

t->exp=q->exp;

q=q->next;

}

s->next=t;

s=t;

}

}

if (q) p=q;//p恒指向余下的项

while (p)

{

t=new Node;

t->coef=p->coef;

t->exp=p->exp;

s->next=t;

s=t;

p=p->next;

}

s->next=0; //链表尾标记

s=temp.head;

temp.head=s->next;

delete s; //删除多余的头结点

return temp;

}

CPolynominal operator -(CPolynominal a,CPolynominal b)//重载-运算符

{

CPolynominal temp;

Node *p,*q,*s=0,*t;

//在此处添加代码，完成此函数(模仿上述重载"+"的函数)

double x;

s=new Node;temp.head=s;//先增加一个头结点

p=a.head;

q=b.head;

while (p && q)

{

if (p->exp==q->exp)

{

x=p->coef-q->coef;

if (x!=0.0)

{

t=new Node;

t->exp=p->exp;

t->coef=x;

s->next=t;

s=t;

}

p=p->next;

q=q->next;

}

else

{

t=new Node;

if(p->exp>q->exp)

{

t->coef=p->coef;

t->exp=p->exp;

p=p->next;

}

else

{

t->coef=-q->coef;

t->exp=q->exp;

q=q->next;

}

s->next=t;

s=t;

}

}

if (q) p=q;//p恒指向余下的项

while (p)

{

t=new Node;

t->coef=p->coef;

t->exp=p->exp;

s->next=t;

s=t;

p=p->next;

}

s->next=0; //链表尾标记

s=temp.head;

temp.head=s->next;

delete s; //删除多余的头结点

return temp;

}

CPolynominal operator *(CPolynominal a,CPolynominal b)//重载*运算符

{

CPolynominal temp;

Node *p,*q,*s;

int e;double c;

p=a.head;

while (p)

{

q=b.head;

while (q)

{

c=p->coef*q->coef;

e=p->exp+q->exp;

s=temp.get(e);//查temp中有无指数为e的项

if (s)//temp中无指数为e的项

s->coef+=c;

else//temp中无指数为e的项

temp.set(c,e);

q=q->next;

}

p=p->next;

}

return temp;

}

ostream& operator<<(ostream& os, const CPolynominal& a)

{

a.Print(os);

阅读更多 >>> 如何提公因式

return os;

}

CPolynominal& CPolynominal::operator =(CPolynominal a)//重载=运算符

{

Node *s,*p;

if (head)

{ //若原多项式存在，先撤消它

p=head;

while (p)

{

s=p->next;

delete p;

p=s;

}

}

Copy(a);

return *this;

}

CPolynominal& CPolynominal::operator +=(CPolynominal a)//重载+=运算符

{

*this = operator +(*this,a);

}

void CPolynominal::operator -=(CPolynominal a)//重载-=运算符

{

*this = operator -(*this,a);

}

void CPolynominal::operator *=(CPolynominal a)//重载*=运算符

{

*this = operator *(*this,a);

}

void CPolynominal::Print(ostream& os) const//显示多项式

{

Node* p;int e;

if (head)

{

e=head->exp;

os<<"f(x)="<

coef;

if (e>1) os<<"x^"<
<e;
if (e==1) os<<"x";

}

else

{

os << "f(x)=0" << endl;

return;

}

p=head->next;

while (p)

{

e=p->exp;

if (p->coef!=0.0)//系数非零

{

if (p->coef>0.0) os<<'+'<

coef;

else os<

coef;

if (e>1) os<<"x^"<
<e;
if (e==1) os<<"x";

}

p=p->next;

}

os<
<endl;
}

int main()

{

int e1[]={6,5,4,3,1};

double c1[]={2.5,3,-5,1.6,-2};

int e2[]={6,3,2,1,0};

double c2[]={-2.5,6,2.8,-1,8};

CPolynominal p1,p2,p3;

p1.Create(c1,e1,5);//创建多项式p1

p2.Create(c2,e2,5);//创建多项式p2

cout<<"多项式p1为";p1.Print();//显示多项式p1

cout<<"多项式p2为";p2.Print();//显示多项式p2

p3 = p1 + p2;

cout<<"多项式p1+p2为"<< p3;//显示多项式p3(p1+p2)

p3 = p1 - p2;

cout<<"多项式p1-p2为"<< p3;//显示多项式p3(p1-p2)

p3 = p1*p2;

cout<<"多项式p1*p2为"<
<p3; 显示多项式p3(p1*p2)
p1 += p2;

cout<<"执行p1+=p2后,多项式p1为" << p1;

p1 -= p2;

cout<<"执行p1-=p2后,多项式p1为" << p1;

p1*=p2;

cout<<"执行p1*=p2后,多项式p1为" << p1;

cout << "p2(1) = " << p2.Val(1) << endl;

system("pause");

return 0;

}

#include

#include

using

namespace

std;

struct

Node//链表结点

{

int

exp;//指数

double

coef;//系数

Node

*next;

};

class

CPolynominal

{

public:

CPolynominal(){

head=0;

}

CPolynominal(const

CPolynominal

&);//复制构造函数

~CPolynominal()

{

Node

*q,*p;

p=head;

while

(p)//删除链表

{

q=p->next;

if

(p)

delete

p;

p=q;

}

head=NULL;

}

Node*

get(int

e);//读取指数为e的项,返回其指针

void

set(double

c,int

e);//设置指数为e的项的系数为c

void

Create(double

*c,int

*e,int

n);//创建多项式

friend

CPolynominal

operator

+(CPolynominal

a,CPolynominal

b);//重载+运算符

friend

CPolynominal

operator

-(CPolynominal

a,CPolynominal

b);//重载-运算符

friend

CPolynominal

operator

*(CPolynominal

a,CPolynominal

b);//重载*运算符

friend

ostream&

operator<<(ostream&

os,

const

CPolynominal&

a);

CPolynominal&

operator

=(CPolynominal

a);//重载=运算符

CPolynominal&

operator

+=(CPolynominal

a);//重载+=运算符

void

operator

-=(CPolynominal

a);//重载-=运算符

void

operator

*=(CPolynominal

a);//重载*=运算符

void

Print(ostream&

os

=

cout)

const;

void

Copy(const

CPolynominal

&a);

double

Val(double

x);

//求多项式f(x)的值

void

Addr(){cout<<"链表头指针值为:"<
<head<<endl;}
private:

Node

*head;//链表头指针

};

double

CPolynominal::Val(double

x)

{

Node

*p

=

head;

double

sum

=

0.0;

while

(p)

{

sum

+=

p->coef

*

pow(x,

p->exp);

p

=

p->next;

}

return

sum;

}

void

CPolynominal::Copy(const

CPolynominal

&a)

{

//复制对象(公用函数)

Node

*t,*s,*p;

p=a.head;s=head=0;

while(p)

{

t=new

Node;

if

(head==0)

head=t;

t->coef=p->coef;

t->exp=p->exp;

p=p->next;

if(s)

s->next=t;

s=t;

}

if

(s)

s->next=0;

}

CPolynominal::CPolynominal(const

CPolynominal&

a)//复制构造函数

{

Copy(a);

}

void

CPolynominal::Create(double

*c,int

*e,int

n)//创建多项式

{

if

(n<1)

cout<<"错误:要创建多项式的项数必须大于零。\n";

else

{

head=new

Node;//创建头结点

head->coef=c[0];

head->exp=e[0];

Node

*q,*p=head;

for

(int

i=1;i
<n;i++)
{

q=new

Node;

q->coef=c[i];

q->exp=e[i];

p->next=q;

p=q;

}

p->next=0;

}

}

Node*

CPolynominal::get(int

e)//读取指数为e的项

{

Node

*p=head;

while

(p)

{

if

(p->exp==e)

return

p;

p=p->next;

}

return

p;//没有找到，返回空指针

}

void

CPolynominal::set(double

c,int

e)

{//将指数为e系数为c的项加入多项式(原多项式无指数为e的项)

Node

*q,*p,*t;

t=new

Node;

t->coef=c;

t->exp=e;

if

(head==0)

{

head=t;

head->next=0;

return;

}

if

(e>head->exp)

{

t->next=head;

head=t;//插入头部

return;

}

p=head;

while

(p

&&

e

exp)

{

q=p;

p=p->next;

}

if

(p)

{

//新的项插入p所指结点前

t->next=p;

q->next=t;

}

else//插入尾部

{

q->next=t;

t->next=0;

}

}

CPolynominal

operator

+(CPolynominal

a,CPolynominal

b)//重载+运算符

{

CPolynominal

temp;

Node

*p,*q,*s,*t;

double

x;

s=new

Node;temp.head=s;//先增加一个头结点

p=a.head;

q=b.head;

while

(p

&&

q)

{

if

(p->exp==q->exp)

{

x=p->coef+q->coef;

if

(x!=0.0)

{

t=new

Node;

t->exp=p->exp;

t->coef=x;

s->next=t;

s=t;

}

p=p->next;

q=q->next;

}

else

{

t=new

Node;

if(p->exp>q->exp)

{

t->coef=p->coef;

t->exp=p->exp;

p=p->next;

}

else

{

t->coef=q->coef;

t->exp=q->exp;

q=q->next;

}

s->next=t;

s=t;

}

}

if

(q)

p=q;//p恒指向余下的项

while

(p)

{

t=new

Node;

t->coef=p->coef;

t->exp=p->exp;

s->next=t;

s=t;

p=p->next;

}

s->next=0;

//链表尾标记

s=temp.head;

temp.head=s->next;

delete

s;

//删除多余的头结点

return

temp;

}

CPolynominal

operator

-(CPolynominal

a,CPolynominal

b)//重载-运算符

{

CPolynominal

temp;

Node

*p,*q,*s=0,*t;

//在此处添加代码，完成此函数(模仿上述重载"+"的函数)

double

x;

s=new

Node;temp.head=s;//先增加一个头结点

p=a.head;

q=b.head;

while

(p

&&

q)

{

if

(p->exp==q->exp)

{

x=p->coef-q->coef;

if

(x!=0.0)

{

t=new

Node;

t->exp=p->exp;

t->coef=x;

s->next=t;

s=t;

}

p=p->next;

q=q->next;

}

else

{

t=new

Node;

if(p->exp>q->exp)

{

t->coef=p->coef;

t->exp=p->exp;

p=p->next;

}

else

{

t->coef=-q->coef;

t->exp=q->exp;

q=q->next;

}

s->next=t;

s=t;

}

}

if

(q)

p=q;//p恒指向余下的项

while

(p)

{

t=new

Node;

t->coef=p->coef;

t->exp=p->exp;

s->next=t;

s=t;

p=p->next;

}

s->next=0;

//链表尾标记

s=temp.head;

temp.head=s->next;

delete

s;

//删除多余的头结点

return

temp;

}

CPolynominal

operator

*(CPolynominal

a,CPolynominal

b)//重载*运算符

{

CPolynominal

temp;

Node

*p,*q,*s;

int

e;double

c;

p=a.head;

while

(p)

{

q=b.head;

while

(q)

{

c=p->coef*q->coef;

e=p->exp+q->exp;

s=temp.get(e);//查temp中有无指数为e的项

if

(s)//temp中无指数为e的项

s->coef+=c;

else//temp中无指数为e的项

temp.set(c,e);

q=q->next;

}

p=p->next;

}

return

temp;

}

ostream&

operator<<(ostream&

os,

const

CPolynominal&

a)

{

a.Print(os);

return

os;

}

CPolynominal&

CPolynominal::operator

=(CPolynominal

a)//重载=运算符

{

Node

*s,*p;

if

(head)

{

//若原多项式存在，先撤消它

p=head;

while

(p)

{

s=p->next;

delete

p;

p=s;

}

}

Copy(a);

return

*this;

}

CPolynominal&

CPolynominal::operator

+=(CPolynominal

a)//重载+=运算符

{

*this

=

operator

+(*this,a);

}

void

CPolynominal::operator

-=(CPolynominal

a)//重载-=运算符

{

*this

=

operator

-(*this,a);

}

void

CPolynominal::operator

*=(CPolynominal

a)//重载*=运算符

{

*this

=

operator

*(*this,a);

}

void

CPolynominal::Print(ostream&

os)

const//显示多项式

{

Node*

p;int

e;

if

(head)

{

e=head->exp;

os<<"f(x)="<

coef;

if

(e>1)

os<<"x^"<
<e;
if

(e==1)

os<<"x";

}

else

{

os

<<

"f(x)=0"

<<

endl;

return;

}

p=head->next;

while

(p)

{

e=p->exp;

if

(p->coef!=0.0)//系数非零

{

if

(p->coef>0.0)

os<<'+'<

阅读更多 >>> symmetric,轴对称的意义,性质,特征各是什么

coef;

else

os<

coef;

if

(e>1)

os<<"x^"<
<e;
if

(e==1)

os<<"x";

}

p=p->next;

}

os<
<endl;
}

int

main()

{

int

e1[]={6,5,4,3,1};

double

c1[]={2.5,3,-5,1.6,-2};

int

e2[]={6,3,2,1,0};

double

c2[]={-2.5,6,2.8,-1,8};

CPolynominal

p1,p2,p3;

p1.Create(c1,e1,5);//创建多项式p1

p2.Create(c2,e2,5);//创建多项式p2

cout<<"多项式p1为";p1.Print();//显示多项式p1

cout<<"多项式p2为";p2.Print();//显示多项式p2

p3

=

p1

+

p2;

cout<<"多项式p1+p2为"<<

p3;//显示多项式p3(p1+p2)

p3

=

p1

-

p2;

cout<<"多项式p1-p2为"<<

p3;//显示多项式p3(p1-p2)

p3

=

p1*p2;

cout<<"多项式p1*p2为"<
<p3; 显示多项式p3(p1*p2)
p1

+=

p2;

cout<<"执行p1+=p2后,多项式p1为"

<<

p1;

p1

-=

p2;

cout<<"执行p1-=p2后,多项式p1为"

<<

p1;

p1*=p2;

cout<<"执行p1*=p2后,多项式p1为"

<<

p1;

cout

<<

"p2(1)

=

"

<<

p2.Val(1)

<<

endl;

system("pause");

return

0;

}

</endl;
</e;

</e;

</n;i++)
</head<<endl;}

</endl;
</e;

</e;

</n;i++)
</head<<endl;}

多项式拟合平方误差怎么求

线性模型（二）之多项式拟合
1. 多项式拟合问题
??多项式拟合（polynominal curve fitting）是一种线性模型，模型和拟合参数的关系是线性的。多项式拟合的输入是一维的，即x=xx=x，这是多项式拟合和线性回归问题的主要区别之一。
??多项式拟合的目标是构造输入xx的MM阶多项式函数，使得该多项式能够近似表示输入xx和输出yy的关系，虽然实际上xx和yy的关系并不一定是多项式，但使用足够多的阶数，总是可以逼近表示输入xx和输出yy的关系的。
??多项式拟合问题的输入可以表示如下：
D={(x1,y1),(x2,y2),...,(xi,yi),...,(xN,yN)}xi∈Ryi∈R
D={(x1,y1),(x2,y2),...,(xi,yi),...,(xN,yN)}xi∈Ryi∈R
??目标输出是得到一个多项式函数：
f(x)=w1x1+w2x2+wixi+...+wMxM+b=(∑i=1Mwixi)+b
f(x)=w1x1+w2x2+wixi+...+wMxM+b=(∑i=1Mwixi)+b
其中MM表示最高阶数为MM。
??可见在线性拟合的模型中，共包括了(M+1)(M+1)个参数，而该模型虽然不是输入xx的线性函数，但却是(M+1)(M+1)个拟合参数的线性函数，所以称多项式拟合为线性模型。对于多项式拟合问题，其实就是要确定这(M+1)(M+1)个参数，这里先假设阶数MM是固定的（MM是一个超参数，可以用验证集来确定MM最优的值，详细的关于MM值确定的问题，后面再讨论），重点就在于如何求出这(M+1)(M+1)个参数的值。
2.优化目标
??多项式拟合是利用多项式函数逼近输入xx和输出yy的函数关系，通过什么指标来衡量某个多项式函数的逼近程度呢？（其实这就是误差/损失函数）。拟合/回归问题常用的评价指标是均方误差（在机器学习中的模型评估与度量博客中，我进行了介绍）。多项式拟合问题也同样采用该评价指标，以均方误差作为误差/损失函数，误差函数越小，模型越好。
E(w,b)=1N∑i=1N[f(xi)?yi]2
E(w,b)=1N∑i=1N[f(xi)?yi]2
??系数1N1N是一常数，对优化结果无影响，可以去除，即将均方误差替换为平方误差：
E(w,b)=∑i=1N[f(xi)?yi]2
E(w,b)=∑i=1N[f(xi)?yi]2
?? 到这里，就成功把多项式拟合问题变成了最优化问题，优化问题可表示为：
argminw,bE(w,b)
arg?minw,b?E(w,b)
即需要求得参数{w1,...,wM,b}{w1,...,wM,b}的值，使得E(w,b)E(w,b)最小化。那么如何对该最优化问题求解呢？
3. 优化问题求解
3.1 求偏导，联立方程求解
?? 直观的想法是，直接对所有参数求偏导，令偏导为0，再联立这M+1M+1个方程求解（因为共有M+1M+1个参数，故求偏导后也是得到M+1M+1个方程）。
E(w,b)=∑i=1N[f(xi)?yi]2=∑i=1N[(w1x1i+w2x2i+wixji+...+wMxMi+b)?yi]2
E(w,b)=∑i=1N[f(xi)?yi]2=∑i=1N[(w1xi1+w2xi2+wixij+...+wMxiM+b)?yi]2
利用E(w,b)E(w,b)对各个参数求偏导，如下：
?E(w,b)?wj?E(w,b)?b=2∑i=1N[(w1x1i+w2x2i+wixji+...+wMxMi+b)?yi]xji=2∑i=1N[(w1x1i+w2x2i+wixji+...+wMxMi+b)?yi]
?E(w,b)?wj=2∑i=1N[(w1xi1+w2xi2+wixij+...+wMxiM+b)?yi]xij?E(w,b)?b=2∑i=1N[(w1xi1+w2xi2+wixij+...+wMxiM+b)?yi]
求导之后，将各个点(xi,yi)(xi,yi)的值带入偏导公式，联立方程求解即可。
??针对该解法，可以举个例子详细说明，比如有两个点(2,3),(5,8)(2,3),(5,8),需要利用二阶多项式f(x)=w1x+w2x2+bf(x)=w1x+w2x2+b拟合。求解过程如下：
该二阶多项式对参数求偏导得到
?E(w,b)?wj?E(w,b)?b=2∑i=12[(w1x1i+w2x2i+b)?yi]xji=[(w1x1+w2x21+b)?y1]xj1+[(w1x2+w2x22+b)?y2]xj2=2∑i=12[(w1x1i+w2x2i+b)?yi]=[(w1x1+w2x21+b)?y1]+[(w1x2+w2x22+b)?y2]
?E(w,b)?wj=2∑i=12[(w1xi1+w2xi2+b)?yi]xij=[(w1x1+w2x12+b)?y1]x1j+[(w1x2+w2x22+b)?y2]x2j?E(w,b)?b=2∑i=12[(w1xi1+w2xi2+b)?yi]=[(w1x1+w2x12+b)?y1]+[(w1x2+w2x22+b)?y2]
将点(2,3),(5,8)(2,3),(5,8)带入方程，可以得到3个方程，
2b+7w1+29w2=117b+29w1+133w2=4629b+133w1+641w2=212
2b+7w1+29w2=117b+29w1+133w2=4629b+133w1+641w2=212
联立这三个方程求解，发现有无穷多的解，只能得到3w1+21w2=53w1+21w2=5，这三个方程是线性相关的，故没有唯一解。
??该方法通过求偏导，再联立方程求解，比较复杂，看着也很不美观。那么有没有更加方便的方法呢？
3.2 最小二乘法
?? 其实求解该最优化问题（平方和的最小值）一般会采用最小二乘法（其实最小二乘法和求偏导再联立方程求解的方法无本质区别，求偏导也是最小二乘法，只是这里介绍最小二乘的矩阵形式而已）。最小二乘法（least squares），从英文名非常容易想到，该方法就是求解平方和的最小值的方法。
??可以将误差函数以矩阵的表示(NN个点，最高MM阶)为：
∥Xw?y∥2
‖Xw?y‖2
其中，把偏置bb融合到了参数ww中，
w={b,w1,w2,...,wM}
w={b,w1,w2,...,wM}
XX则表示输入矩阵，
??????11...1x1x2...xNx21x22...x2N............xM1xM2...xMN??????
[1x1x12...x1M1x2x22...x2M...............1xNxN2...xNM]
yy则表示标注向量，
y={y1,y2,...,yN}T
y={y1,y2,...,yN}T
因此，最优化问题可以重新表示为
minw∥Xw?y∥2
minw‖Xw?y‖2
对其求导，
?∥Xw?y∥2?w=?(Xw?y)T(Xw?y)?w=?(wTXT?yT)(Xw?y)?w=?(wTXTXw?yTXw?wTXTy+yTy)?w
?‖Xw?y‖2?w=?(Xw?y)T(Xw?y)?w=?(wTXT?yT)(Xw?y)?w=?(wTXTXw?yTXw?wTXTy+yTy)?w
在继续对其求导之前，需要先补充一些矩阵求导的先验知识（常见的一些矩阵求导公式可以参见转载的博客https://blog.csdn.net/lipengcn/article/details/52815429），如下：
?xTa?x=a?ax?x=aT?xTA?x=Ax+ATx
?xTa?x=a?ax?x=aT?xTA?x=Ax+ATx
根据上面的矩阵求导规则，继续进行损失函数的求导
?∥Xw?y∥2?w=?(wTXTXw?yTXw?wTXTy+yTy)?w=XTXw+(XTX)Tw?(yTX)T?XTy=2XTXw?2XTy
?‖Xw?y‖2?w=?(wTXTXw?yTXw?wTXTy+yTy)?w=XTXw+(XTX)Tw?(yTX)T?XTy=2XTXw?2XTy
其中XTXw=(XTX)TwXTXw=(XTX)Tw.令求导结果等于0，即可以求导问题的最小值。
2XTXw?2XTy=0w=(XTX)?1XTy
2XTXw?2XTy=0w=(XTX)?1XTy
??再利用最小二乘法的矩阵形式对前面的例子进行求解，用二阶多项式拟合即两个点(2,3),(5,8)(2,3),(5,8)。
表示输入矩阵 XX和标签向量yy
X=[1125425]y=[38]T
X=[1241525]y=[38]T
计算XTXXTX
XTX=???272972913800???
XTX=[272972913800]
矩阵求逆，再做矩阵乘法运算
但 XTXXTX不可逆，故无唯一解。
??关于矩阵的逆是否存在，可以通过判断矩阵的行列式是否为0（det(A)=?0det(A)=?0 来判断，也可以通过初等行变换，观察矩阵的行向量是否线性相关，在这个例子下，矩阵不可逆，故有无穷多解。但如果新增一个点(4,7)(4,7)，则就可以解了。
??其实这和数据集的点数和选择的阶数有关，如果点数小于阶数则会出现无穷解的情况，如果点数等于阶数，那么刚好有解可以完全拟合所有数据点，如果点数大于阶数，则会求的近似解。
??那么对于点数小于阶数的情况，如何求解？在python的多项式拟合函数中是可以拟合的，而且效果不错，具体算法不是很了解，可以想办法参考python的ployfit()函数的实现。
4. 拟合阶数的选择
?? 在前面的推导中，多项式的阶数被固定了，那么实际场景下应该如何选择合适的阶数MM呢？
一般会选择阶数MM小于点数NN
把训练数据分为训练集合验证集，在训练集上，同时用不同的MM值训练多个模型，然后选择在验证集误差最小的阶数M</script

高分 C++数据结构，一元多项式的相乘

这个我当初学数据结构的时候做过，有点复杂！自己好琢磨琢磨吧！
看我的：
#include "Polynomial.h"
#include
using namespace std;
void Polynomial::DestroyLink(Link &L)
{
Link p;
p=L->next;
while(p)
{
L->next=p->next;
delete p;
p=L->next;
}
delete L;
L=NULL;
}
//创建含有n个链表类型结点的项，即创建一个n项多项式
void Polynomial::CreateLink(Link &L,int n)
{
if(L!=NULL)
{
DestroyLink(L);
}
Link p,newp;
L=new LNode;
L->next=NULL;
(L->data).exp=-1;//创建头结点
p=L;
for(int i=1;i <=n;i++)
{
newp=new LNode;
cout <<"请输入第" <<i <<"项的系数和指数:" <<endl;
cout <<"系数:";
cin>>(newp->data).coef;
cout <<"指数:";
cin>>(newp->data).exp;
if(newp->data.exp <0)
{
cout <<"输入有误，指数不允许为负值!" <<endl;
delete newp;
i--;
continue;
}
newp->next=NULL;
p=L;
if(newp->data.coef==0)
{
cout <<"系数为零，请重新输入!" <<endl;
delete newp;
i--;
continue;
}
while((p->next!=NULL)&&((p->next->data).exp data).exp))
{
p=p->next; //p指向指数最小的那一个
}
newp->next=p->next;
p->next=newp;
}
}
/*输出链表*/
void Polynomial::PrintList(Link L)
{
Link p;
if(L==NULL||L->next==NULL)
cout <<"该一元多项式为空！" <<endl;
else
{
p=L->next;
//项的系数大于0的5种情况
if((p->data).coef>0)
{
if((p->data).exp==0)
cout <data).coef;
else if((p->data).coef==1&&(p->data).exp==1)
cout <<"x";
else if((p->data).coef==1&&(p->data).exp!=1)
cout <<"x^" <data).exp;
else if((p->data).exp==1&&(p->data).coef!=1)
cout <data).coef <<"x";
else cout <data).coef <<"x^" <data).exp;
}
//项的系数小于0的5种情况
if((p->data).coef <0)
{
if((p->data).exp==0)
cout <data).coef;
else if(p->data.coef==-1&&p->data.exp==1)
cout <<"-x";
else if(p->data.coef==-1&&p->data.exp!=1)
cout <<"-x^" <data.exp;
else if(p->data.exp==1)
cout <data.coef <<"x";
else cout <data).coef <<"x^" <data).exp;
}
p=p->next;
while(p!=NULL)
{
if((p->data).coef>0)
{
if((p->data).exp==0)
cout <<"+" <data).coef;
else if((p->data).exp==1&&(p->data).coef!=1)
cout <<"+" <data).coef <<"x";
else if((p->data).exp==1&&(p->data).coef==1)
cout <<"+" <<"x";
else if((p->data).coef==1&&(p->data).exp!=1)
cout <<"+" <<"x^" <data).exp;
else cout <<"+" <data).coef <<"x^" <data).exp;
}
if((p->data).coef <0)
{
if((p->data).exp==0)
cout <data).coef;
else if(p->data.coef==-1&&p->data.exp==1)
cout <<"-x";
else if(p->data.coef==-1&&p->data.exp!=1)
cout <<"-x^" <data.exp;
else if(p->data.exp==1)
cout <data.coef <<"x";
else cout <data).coef <<"x^" <data).exp;
}
p=p->next;
}
}
cout <<endl;
}
/*把一个链表的内容复制给另一个链表*/
void Polynomial::CopyLink(Link &pc,Link pa)
{
Link p,q,r;
pc=new LNode;
pc->next=NULL;
r=pc;
p=pa;
while(p->next!=NULL)
{
q=new LNode;
q->data.coef=p->next->data.coef;
q->data.exp=p->next->data.exp;
r->next=q;
q->next=NULL;
r=q;
p=p->next;
}
}
/*将两个一元多项式相加*/
void Polynomial::PolyAdd(Link &pc,Link pa,Link pb)
{
Link p1,p2,p,pd;
CopyLink(p1,pa);
CopyLink(p2,pb);
pc=new LNode;
pc->next=NULL;
p=pc;
p1=p1->next;
p2=p2->next;
while(p1!=NULL&&p2!=NULL)
{
if(p1->data.exp data.exp)
{
p->next=p1;
p=p->next;
p1=p1->next;
}
else if(p1->data.exp>p2->data.exp)
{
p->next=p2;
p=p->next;
p2=p2->next;
}
else
{
p1->data.coef=p1->data.coef+p2->data.coef;
if(p1->data.coef!=0)
{
p->next=p1;
p=p->next;
p1=p1->next;
p2=p2->next;
}
else
{
pd=p1;
p1=p1->next;
p2=p2->next;
delete pd;
}
}
}
if(p1!=NULL)
{
p->next=p1;
}
if(p2!=NULL)
{
p->next=p2;
}
}
/*将两个多项式相减*/
void Polynomial::PolySubstract(Link &pc,Link pa,Link pb)
{
Link p,pt;
CopyLink(pt,pb);
p=pt;
while(p!=NULL)
{
(p->data).coef=(-(p->data).coef);
p=p->next;
}
PolyAdd(pc,pa,pt);
DestroyLink(pt);
}
//清屏函数
void Polynomial::Clear()
{
system("pause");
system("cls");
}
Polynomial::Polynomial()
{
a=0;
}
#include "Polynomial.h"
#include
using namespace std;
void Menu()
{
cout <<"\t----\t\t输入“1”：创建两个一元多项式\t\t ----" <<endl;
cout <<"\t----\t\t输入“2”：将两个一元多项式进行相加\t ----" <<endl;
cout <<"\t----\t\t输入“3”：将两个一元多项式进行相减\t ----" <<endl;
}

//判断输入的整数是不是为1到2的数字
int CompareIfNum(int i)
{
if(i>0&&i <8)
return 0;
else return 1;
}
int main()
{
Polynomial test;
int n;
Link L,pc=NULL,pa=NULL,pb=NULL,La=NULL,Lb=NULL;//La,Lb分别为创建的两个多项式
int choose;
while(1)
{
Menu(); //调用菜单函数
cin>>choose;
switch(choose)
{
case 1:
cout <<"请输入你要运算的第一个一元多项式的项数:" <<endl;
cin>>n;
if(CompareIfNum(n)==1)
{
cout <<"您的输入有误，请重新输入！" <<endl;
test.Clear();
break;
}
test.CreateLink(La,n);
cout <<"请输入您要运算的第二个一元多项式的项数:" <<endl;
cin>>n;
if(CompareIfNum(n)==1)
{
cout <<"您的输入有误，请重新输入！" <<endl;
test.Clear();
break;
}
test.CreateLink(Lb,n);
test.Clear();
break;
case 3:
if(La==NULL||Lb==NULL)
{
cout <<"您的多项式创建有误，请重新选择！" <<endl;
test.Clear();
break;
}

test.PolySubstract(L,La,Lb);
cout <<"要相减的两个一元多项式分别为：" <<endl;
test.PrintList(La);
test.PrintList(Lb);
cout <<"两个式子相减后的结果为：" <<endl;
test.PrintList(L);
test.Clear();
test.DestroyLink(L);
break;

case 2:
if(La==NULL||Lb==NULL)
{
cout <<"您的多项式创建有误，请重新选择！" <<endl;
test.Clear();
break;
}

test.PolyAdd(L,La,Lb);
cout <<"要相加的两个一元多项式分别为：" <<endl;
test.PrintList(La);
test.PrintList(Lb);
cout <<"两个式子相加后的结果为：" <<endl;
test.PrintList(L);
test.Clear();
test.DestroyLink(L);
break;
}
}
return 0;
}
#ifndef POLYNOMIAL_H
#define POLYNOMIAL_H
struct Node
{
float coef;//结点类型
int exp;
};
typedef Node polynomial;
struct LNode
{
polynomial data;//链表类型
LNode *next;
};
typedef LNode* Link;
class Polynomial {
public:
Polynomial();
void CreateLink(Link &L,int n);
void PrintList(Link L);
void PolyAdd(Link &pc,Link pa,Link pb);
void PolySubstract(Link &pc,Link pa,Link pb);
void CopyLink(Link &pc,Link pa);
void DestroyLink(Link &L);
void Clear();
private:
int a;
};
#endif

问有xyz数据后如何拟合出z=f(x,y)的函数关系

二维数据拟合
试试这个
function p = polyfit2d(x,y,z,n,m)
% P= POLYFIT2D(x,y,z,n,m) finds the coefficients of a
% polynomial function of 2 variables formed from the
% data in vectors x and y of degrees n and m, respectively,
% that fit the data in vector z in a least-squares sense.
%
% The regression problem is formulated in matrix format as:
%
% z = A*P So that if the polynomial is cubic in
% x and linear in y, the problem becomes:
%
% z = [y.*x.^3 y.*x.^2 y.*x y x.^3 x.^2 x ones(length(x),1)]*
% [p31 p21 p11 p01 p30 p20 p10 p00]'
%
% Note that the various xy products are column vectors of length(x).
%
% The coefficents of the output p
% matrix are arranged as shown:
%
% p31 p30
% p21 p20
% p11 p10
% p01 p00
%
% The indices on the elements of p correspond to the
% order of x and y associated with that element.
%
% For a solution to exist, the number of ordered
% triples [x,y,z] must equal or exceed (n+1)*(m+1).
% Note that m or n may be zero.
%
% To evaluate the resulting polynominal function,
% use POLYVAL2D.
% Perry W. Stout June 29, 1995
% 4829 Rockland Way
% Fair Oaks, CA 95628
% (916) 966-0236
% Based on the Matlab function polyfit.
if any((size(x) ~= size(y)) | (size(z) ~= size(y)))
error('X, Y,and Z vectors must be the same size')
end
x = x(:); y = y(:); z= z(:); % Switches vectors to columns--matrices, too
if length(x) < (n+1)*(m+1)
error('Number of points must equal or exceed order of polynomial function.')
end
n = n + 1;
m = m + 1; % Increments n and m to equal row, col numbers of p.
a = zeros(max(size(x)),n*m);
% Construct the extended Vandermonde matrix, containing all xy products.
for i1= 1:m
for j1=1:n
a(:,j1+(i1-1)*n) = (x.^(n-j1)).*(y.^(m-i1));
end
end
p1 = (a\z);
% Reform p as a matrix.
p=[];
for i1=1:m
p=[p, p1((n*(i1-1)+1):(n*i1))];
end
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
function z = polyval2d(c,x,y)
% z = POLYVAL2D(V,sx,sy) Two dimensional polynomial evaluation.
%
% If V is a matrix whose elements are the coefficients of a
% polynomial function of 2 variables, then POLYVAL2D(V,sx,sy)
% is the value of the polynomial evaluated at [sx,sy]. Row
% numbers in V correspond to powers of x, while column numbers
% in V correspond to powers of y. If sx and sy are matrices or
% vectors,the polynomial function is evaluated at all points
% in [sx, sy].
%
% If V is one dimensional, POLYVAL2D returns the same result as
% POLYVAL.
%
% Use POLYFIT2D to generate appropriate polynomial matrices from
% f(x,y) data using a least squares method.
% Perry W. Stout June 28, 1995
% 4829 Rockland Way
% Fair Oaks, CA 95628
% (916) 966-0236
% Based on the Matlab function POLYVAL.
% Polynomial evaluation c(x,y) is implemented using Horner's slick
% method. Note use of the filter function to speed evaluation when
% the ordered pair [sx,sy] is single valued.
if nargin==2
y=ones(x); end
if any(size(x) ~= size(y))
error('x and y must have the same dimensions.')
end
[m,n] = size(x);
[rown,coln]= size(c);
if (m+n) == 2
% Use the built-in filter function when [sx,sy] is single valued
% to implement Hoerner's method.
z= 0;
for i1= 1:coln
ccol= c(:,coln+1-i1);
w = filter(1,[1 -x],ccol);
w = w(rown)*(y^(i1-1));
z= z+w;
end
return
end % Of the scalar computation
% Do general case where X and Y are arrays
z = zeros(m,n);
for i1=1:coln
ccol= c(:,coln+1-i1);
w= zeros(m,n);
for j1=1:rown
w = x.*w + ccol(j1) * ones(m,n);
end
z= z+w.*(y.^(i1-1));
end

我在网上下载了matlab的源代码，谁能告诉我怎么使用

将代码保存在matlab中就可以用了
例如：function[poly]=polyadd(poly1,poly2)
%polyadd(poly1,poly2) adds two polynominals possibly of uneven length
if length(poly1)<length(poly2)
short=poly1;
long=poly2;
else
short=poly2;
long=poly1;
end
mz=length(long)-length(short);
if mz>0
poly=[zeros(1,mz),short]+long;
else
poly=long+short;
end
保存名为polyadd.M 在matlab中输入polyadd就可以调用了
将directory改为m文件的目录下，然后在正常的窗口里输入 xxx.m 说白了就是输入你要运行的m文件的名字
存入当前工作区，
默认的是C:\matlab\wok
如果是函数就能直接用了

matlab 安装完成后，怎么输入命令之后软件不进行计算？？

你确定polyadd是个系统函数？
polyadd()不是MATLAB工具箱中自带的函数，需要自己编写生成。方法如下：
以下函数是由密西根大学的 Justin Shriver 编写的。
function[poly]=polyadd(poly1,poly2)
%polyadd(poly1,poly2) adds two polynominals possibly of uneven length
if length(poly1)<length(poly2)
short=poly1;
long=poly2;
else
short=poly2;
long=poly1;
end
mz=length(long)-length(short);
if mz>0
poly=[zeros(1,mz),short]+long;
else
poly=long+short;
end
将这个函数生成 polyadd.m 文件，并将该文件保存在 MATLAB 搜索路径中的一个目录
下，这样 polyadd 函数就可以和 MATLAB 工具箱中其他函数一样使用了。

为什么我安的MATLAB输入命令字符不对就是输入a 显示的是^ 这是为什么呀？

看看的你的a是否在之前已经定义过a='^'之类的语句，提醒你在运行一个新的程序时最好先执行一下clear命令，这样可以把以前的变量全部删除，希望对你有帮助！
进主程序点File>Preferences>Fonts把默认字体改成Courier New就可以了

polynomial,高分 C++数据结构，一元多项式的相乘

polynomial,高分 C++数据结构，一元多项式的相乘详细介绍

高分 C++数据结构，一元多项式的相乘

问有xyz数据后如何拟合出z=f(x,y)的函数关系

我在网上下载了matlab的源代码，谁能告诉我怎么使用

matlab 安装完成后，怎么输入命令之后软件不进行计算？？

为什么我安的MATLAB输入命令字符不对就是输入a 显示的是^ 这是为什么呀？

少长咸集

知识分享相关文章：

网站数据信息

polynomial,高分 C++数据结构，一元多项式的相乘

polynomial,高分 C++数据结构，一元多项式的相乘详细介绍

高分 C++数据结构，一元多项式的相乘

问有xyz数据后如何拟合出z=f(x,y)的函数关系

我在网上下载了matlab的源代码，谁能告诉我怎么使用

matlab 安装完成后，怎么输入命令之后软件不进行计算？？

为什么我安的MATLAB输入命令字符不对 就是输入a 显示的是^ 这是为什么呀？

少长咸集

知识分享相关文章：

网站数据信息

为什么我安的MATLAB输入命令字符不对就是输入a 显示的是^ 这是为什么呀？