第一次作业报告
教学班：_______________ 完成日期：___________________ 评分：____________
小组名称
组员学号、姓名
和分工
实训名称
实训报告
一、行业分析
1、行业概述
2、行业发展的历史回顾、行业发展的现状与格局分析
3、行业发展趋势分析
4、行业的市场容量、销售增长率现状及趋势预测
二、企业内部分析
1、企业目标
2、定位
3、市场表现
4、资源和能力
5、现有营销策略
三、竞争对手分析
1、主要的竞争对手
2、竞争对手上线的时间
3、竞争对手的产品线和热销产品，竞争对手热销产品的特色，价格和市场表现
4、竞争对手采用的营销策略以及竞争对手未来可能采用的营销措施
5、竞争对手的优点和缺点
四、合作伙伴分析
1、天猫商城介绍
2、企业加入天猫商城的要求和条件
3、选择天猫商城作为合作渠道的优势以及劣势
五、消费者分析
1、消费者人口统计特征
2、消费行为
3、消费动机
4、消费偏好
5、影响消费者购买彩妆的因素
六、卡洛莱在网上运营A&C品牌的SWOT分析
1、优势
2、劣势
3、机会
4、威胁
七、实训感想（可以是实训过程中的心里活动，可以是对实训中所碰到的问题的总结，可以是对今后学习的构想等）
注：此表可延长。
第二篇：数值分析第一次作业报告
数值分析计算实习作业一?
??????????????????????????????? 宋秋 SY1207438
一、 题目分析?
1. 求λ1，λ501和λs的值。?
分析：λs的值可以通过反幂法直接求出。另外可以通过幂法直接求出|λmax?|，依题意，λmax必为λ1，λ501其中一个数。为了确定λ1，λ501的值，可以将矩阵A平移λmax的到新矩阵B，利用幂法求出B按模最大的特征值λB，则λmax+λB也应为λ1，λ501其中一个数，所以只需要比较λmax+λB与λmax的大小即可确定λ1，λ501的值。
这里利用反幂法每一次迭代都需要求解一次关于A的一次线性方程组，这里可以考虑利用Doolittle分解法求解。?
2. 求λik的值。?
分析：由第1问可以得到λ1，λ501的值，这样就可以很方便的计算μk，为了求λik，可以联想λik-μk为某一矩阵K’按模最小的特征值，利用反幂法即可求出。
这时必须要求μk也为另一矩阵K的特征值，为了方便计算，可以定义 K=μk I，I为单位矩阵，则K’=A- K ,这是只要求出K’按模最小的特征值即可得到λik。?
3. 求A的（谱范数）条件数cond(A)2和行列式detA。?
分析：依定义cond(A)2=|λmax|/|λs|，根据前面的结果，这个很容易求出。又直接求detA比较困难，前面反幂法求解用到了Doolittle分解，这detA的值就转换成了求U上三角阵主对角元素的乘积。?
二、 算法方案?
根据第一步解题结果，此题共需要用到Doolittle分解、幂法、反幂法等算法，另外由于A为阶数较多的带状矩阵，还需要用到矩阵的压缩存储算法。?
1. A的压缩存储?
A为带状矩阵，其r=s=2，则压缩矩阵C(m,n)中m=5，n=501；??????且：aij?=?ci‐j+s+1?
2. Doolittle分解（程序中函数：doolittle()）?
注意，对于k=1，2，……，n，detA=?ukk,对于A压缩存储的
。?矩阵C，ukk的值为c[s][k‐1]（矩阵的第s+1行，第k列）
3. LU计算求解线性方程组（程序中函数：LU()）?
该模块要调用Doolittle分解模块，其中b[N]为原方程组右端向量，x[N]用来存储解向量，便于其他函数调用。?
4. 幂法求按模最大的特征值（程序中函数：MIFA()）?
教材中给出了2中幂法迭代公式，为了保证结果的准确性，采用第二种迭代公式；?
另外，迭代公式中有矩阵A与向量y的乘法运算，这里需要注
意的是A中元素i‐j>r或者j‐i>s时都为0，不应进行运算。?
5. 反幂法求按模最小的特征值（程序中函数：FMF()）?
直接按照教材中的迭代公式进行编程即可，需要注意的是每次迭代需要求解一次线性方程组Au=y，程序中可以将A与y作为实参直接调用LU算法，这里虽然是调用函数，LU算法还是会改变A与y地址的内容，所以程序中还需要另外定义一个矩阵和向量来保存A与y的初始值。?
三、 源代码?
#include <stdio.h>
#include <math.h>
#define N 501
#define r 2
#define s 2
#define Epsi 1.0e-12
double ABS(double a); /*返回一个浮点数的绝对值*/ double doolittle(double c[][N]); /*对矩阵进行Doolittle分解*/ void LU(double c[][N],double y[N],double x[N]); /*利用Doolittle分解计算线性方程组的解x*/
double MIFA(double c[][N]); /*幂法计算矩阵按模最大的特征值*/ double FMF(double c[][N]); /*反幂法计算矩阵按模最小的特征值*/ double moveMIFA(double c[][N], double x); /*计算矩阵c平移参数x后的按模最大的特征值*/ double moveFMF(double c[][N], double x); /*计算矩阵c平移参数x后的按模最小的特征值*/
/*-------计算一个浮点数的绝对值-------------*/
double ABS(double a)
{
double b;
if(a>=0) b=a;
if(a<0) b=-a;
return b;
}
/*-------对矩阵进行Doolittle分解-------------*/
double doolittle(double c[][N]) {
int i,j,k,t,min1,min2,max1,max2;
double aa,bb,detc=1.0;
for(i=1;i<=s+r+1;i++)
{
for(j=1;j<=N;j++)
c[i-1][j-1]=c[i-1][j-1];
}
for(k=1;k<=N;k++)
{
min1= (k+s)<N ? (k+s) : N;
for(j=k;j<=min1;j++)
{
max1= (1>k-r) ? 1 : ((k-r)>(j-s)?(k-r):(j-s)); aa=0.0;
for(t=max1;t<=k-1;t++)
{
aa+=c[k-t+s][t-1]*c[t-j+s][j-1]; }
c[k-j+s][j-1]-=aa;
}
if(k<N)
{
min2= (k+r)<N ? (k+r) : N;
for(i=k+1;i<=min2;i++)
{
max2= (1>i-r)? 1 : ((i-r)>(k-s)?(i-r):(k-s)); bb=0.0;
for(t=max2;t<=k-1;t++)
{
bb+=c[i-t+s][t-1]*c[t-k+s][k-1]; }
c[i-k+s][k-1]=(c[i-k+s][k-1]-bb)/c[s][k-1]; }
}
}
for(k=1;k<=N;k++) {
detc*=c[s][k-1];
}
return detc;
}
/*计算detA*/
/*-------利用L U矩阵计算解向量x-------------*/
void LU(double c[][N],double y[N],double x[N])
{
int i,j,t,max,min;
double cc,dd,d[s+r+1][N],b[N];
for(i=0;i<(s+r+1);i++) /*重新定义一个矩阵d，防止doolittle分解时改变了原矩阵的值
*/
{
for(j=0;j<N;j++) d[i][j]=c[i][j];
}
for(i=0;i<N;i++) b[i]=y[i]; /*重新定义一个向量y，防止LU计算时改变了原向量的值*/
doolittle(d);
for(i=1;i<=N;i++)
{
cc=0.0;
max=(1>i-r)? 1 : i-r;
for(t=max;t<=i-1;t++)
cc+=(d[i-t+s][t-1]*b[t-1]);
b[i-1]-=cc;
}
x[N-1]=b[N-1]/d[s][N-1];
for(i=N-1;i>=1;i--)
{
dd=0.0;
min=(i+s<N)?i+s:N;
for(t=i+1;t<=min;t++)
dd+=(d[i-t+s][t-1]*x[t-1]);
x[i-1]=(b[i-1]-dd)/d[s][i-1];
}
}
/*-------第二类幂法迭代公式-------------*/
double MIFA(double c[][N])
{
int i,j,r1,k=0;
double u[N],hr,y[N],uk,beta1=0.0,beta2=0.0;
for(i=1;i<=N;i++) /*定义初始向量*/ u[i-1]=1.0;
do
{
beta1=beta2; hr=0.0;
for(i=1;i<=N;i++) hr=(ABS(hr)>ABS(u[i-1])) ? hr : u[i-1]; /*找出u中按模最大的元素*/
for(i=1;i<=N;i++) /*找出hr所在的位置*/
{
if(hr==u[i-1]) break;
}
r1=i;
for(i=1;i<=N;i++) y[i-1]=u[i-1]/ABS(hr); /*计算y向量*/
for(i=1;i<=N;i++) /*计算矩阵A与向量y的乘积*/ {
uk=0.0;
for(j=1;j<=N;j++)
{
if((i-j<=r)&&(j-i)<=s) /*选择A矩阵中部分元素进行运算*/ {
uk+=c[i-j+s][j-1]*y[j-1];
}
}
u[i-1]=uk;
}
beta2=u[r1-1]*y[r1-1]; /*计算误差*/
k++;
}while((ABS(beta2-beta1)/ABS(beta2))>Epsi);
// printf("迭代次数为%-6d\n",k);
return beta2;
}
/*-------反幂法计算按模最小的特征值-------------*/
double FMF(double c[][N])
{
int i,k=0;
double u[N],miu,ut,y[N],beta1=1.0,beta2=1.0,m,n;
for(i=1;i<=N;i++) /*定义初始向量*/ {
u[i-1]=1.0;
}
do
{
ut=0.0;
beta1=beta2; beta2=0.0;
for(i=1;i<=N;i++)
ut+=u[i-1]*u[i-1];
miu=sqrt(ut); /*求向量u的2范数*/
for(i=1;i<=N;i++) /*计算向量y*/
y[i-1]=u[i-1]/miu;
LU(c,y,u); /*调用LU函数求解u*/
for(i=1;i<=N;i++)
beta2+=y[i-1]*u[i-1]; /*计算误差*/
m=1.0/beta2 ; n=1.0/beta1;
k++;
}while((ABS(m-n)/ABS(m))>Epsi);
// printf("迭代次数为%-6d\n",k);
return m;
}
/*-------计算矩阵c平移参数x后的按模最大的特征值-------------*/
double moveMIFA(double c[][N], double x)
{
int i,j;
double NEWa[s+r+1][N],b;
for(i=0;i<s+r+1;i++) /*将矩阵c中第s+1行元素都减去x,并存储在新的矩阵中*/ {
if(i==s)
for(j=0;j<N;j++) NEWa[i][j]=c[i][j]-x;
else
for(j=0;j<N;j++) NEWa[i][j]=c[i][j];
}
b=MIFA(NEWa);
return b;
}
/*-------计算矩阵c平移参数x后的按模最小的特征值-------------*/
double moveFMF(double c[][N], double x)
{
int i,j;
double NEWb[s+r+1][N],b;
for(i=0;i<s+r+1;i++) /*将矩阵c中第s+1行元素都减去x,并存储在新的矩阵中*/ {
if(i==s)
for(j=0;j<N;j++) NEWb[i][j]=c[i][j]-x;
else
for(j=0;j<N;j++) NEWb[i][j]=c[i][j];
}
b=FMF(NEWb);
return b;
}
/*-------主函数-------------*/
main()
{
int i,j;
double a[s+r+1][N],b[s+r+1][N],p,q,deta,cond,miuk[39];
double lamd1,lamd501,lamds,lamdk[39];
for(i=1;i<=s+r+1;i++) /*将A压缩存储在矩阵a中*/ {
if(i==s+1)
{
for(j=1;j<=N;j++)
{
a[i-1][j-1]=(1.64-0.024*j)*sin(0.2*j)-0.64*exp(0.1/j);
b[i-1][j-1]=a[i-1][j-1];
}
}
if(i==(s-1)||i==(s+3))
{
for(j=1;j<=N;j++)
{
a[i-1][j-1]=-0.064;
b[i-1][j-1]=a[i-1][j-1];
}
}
if(i==s||i==(s+2))
{
for(j=1;j<=N;j++)
{
a[i-1][j-1]=0.16;
b[i-1][j-1]=a[i-1][j-1];
}
}
}
deta=doolittle(b); /*计算矩阵A的行列式值*/ p=MIFA(a); /*幂法计算按模最大的特征值*/ lamds=FMF(a); /*反幂法计算按模最小的特征值*/
q=moveMIFA(a,p); /*幂法计算平移后矩阵按模最大的特征值*/ lamd1=(p<(p+q)) ? p : (p+q);
lamd501=(p>(p+q)) ? p : (p+q); /*判断最大特征值与最小特征值*/
for(i=0;i<39;i++) /*计算uk的值，并计算与之最接近的特征值*/ {
miuk[i]=lamd1+(i+1)*(lamd501-lamd1)/40;
lamdk[i]=miuk[i]+moveFMF(a,miuk[i]);
}
cond=(ABS(p))/(ABS(lamds)); /*计算矩阵A的条件数*/
printf("矩阵A最小的特征值为： %16.11e\n",lamd1);
printf("矩阵A最大的特征值为： %16.11e\n",lamd501);
printf("A按模最小的特征值为： %16.11e\n",lamds);
printf("矩阵A的行列式值为： %16.11e\n",deta);
printf("矩阵A的条件数为： %16.11e\n",cond);
for(i=0;i<39;i++)
{
printf("k=%-2d uk=%-8.4f 最接近的特征为： %16.11e\n",i+1,miuk[i],lamdk[i]); }
}
四、 运行结果?
?
?
五、 调试过程?
1. Doolittle分解?
在编写Doolittle分解程序模块是，以detA的值作为检验该模块程序的依据。在开始调试时，发现N值取到150以后显示的detA为“1.#INF0000000e+000”，也就是说程序中出现了无效浮点数，可能是出现了（a/0）的情况，而算法中唯一的除数为c[s+1][k]，经调试发现确实是因为计算中c[s+1][k]值非常小，接近0。经检查发现，在程序中定义了局部变量aa，bb，其中aa=?
k?t?s?1,tt?j?s?1,j
t?max(1,k?r,j?s)?ck?1c?，对于j的每一次取值，都需要先对aa,bb
赋初值0，否则aa的值会不断累加，最终造成?c[s+1][k]趋近0.?
2. 初始向量的选择对结果的影响（以幂法为例）?
1) 初始向量u=(1,1,…，1)T?
运算结果如下图：?
?
?
2) 初始向量u=(0,1,…，1)T?
?
3) 初始向量u=(1,2,…，n)T（等差数列）
?
?
从上述三种初始向量的选择，教材中第二种幂法的迭代次数与计算结果基本一致，因为在第二种算法中，对于给定的初始向量，需要先找出其中绝对值最大的一个，所以能保证结果的准确性与收敛速度。?
同时，当初始向量为一个等差数列时，对A平移后的结果有一些误差，可能是因为hr过大，而矩阵元素很小，造成了一定的舍入误差。?
3. 初始向量的选择对结果的影响（以反幂法为例）?
1) 初始向量u=(1,1,…，1)T?
?
2) 初始向量u=(0,1,…，1)T?
?
3) 初始向量u=(1,2,…，n)T（等差数列）?
?
从上述三种情况可以看出，在第三种初始向量情况下，算法的收敛速度较快，同时结果也比较准确，为了验证，再设置一种初始向量：?
4) 初始向量u=(1,4,7,10，…)T（等差数列）?
?
结果并没有什么差别。分析原因，算法中出现了uk?1/?k?1的运算，uk?1的各分量只有有足够的差值，得到的y各分量才会有差别，在线性方程组求解过程中u的变化才越快，收敛速度会加快，但这几种初始向量的选取方式对于计算结果没有影响。
?