數值演算法第二版

1. c語言誰的書好

潭浩強
清華大學出版社
學C語言的99%都用他的書
以下在網路上看到對他的書的評價
按∶
譚浩強
教授編寫的
《C程序設計
》一書受到廣泛的歡迎和高度評價。下面刊登幾所大學講授C語言
課程
的老師對《C程序設計》一書的評價意見。
清華大學計算機與信息管理中心
承擔著清華大學非
計算機專業
的「計算機軟體技術基礎」課，自1994年起選用清華大學出版的譚浩強教授編寫的《C程序設計》一書作為本課程教材，取得了很好的教學效果，深受師生們的歡迎，現正使用第二版作為
教材
。此書的特點及對教學的
促進作用
主要表現在以下幾方面：
1．內容全面，實用性強
此書涵蓋了程序設計
基礎知識
及C語言程序設計的全部內容，並介紹了大量常用
演算法
。通過學習此教材，初學程序設計的學生可以達到熟練運用C語言進行小規模應用開發的能力。
2．講解透徹，深入淺出
此書對
概念
講解透徹，使初學
計算機程序設計
的學生不僅學習了一種
高級語言
，而且能夠對相關基礎知識有準確深入的理解，例如在介紹
變數
的存儲類型時、介紹指針時都對
計算機
的
存儲管理
做了清楚的論述，使讀者知其然也知期所以然。廣大非計算機專業的學生學習
計算機課程
的學時很少，沒有足夠的
時間系統
地學習計算機專業基礎知識。因此像這樣將必要的基礎知識融會貫通到程序設計課程中，對學生的
知識結構
建設以及今後的深造和提高都大有裨益。
3．通俗易懂，易於自學
此書的一個突出優點就是，語言優美、舉例生動、
淺顯易懂
。學生在學習C語言之前，普遍有些畏難情緒，因為聽說C語言比較難學。的確C語言最初是面向專業
開發人員
的。但是讀了
這本書
之後，學生們不再懼怕C語言。很多學生說，讀這本書不僅
學會
了C語言，而且讀的
過程
本身就是一種享受，不像有些專業書籍，堆砌大量技術
名詞
，艱澀難懂。由於這本書易於自學，給我們的教學工作帶來很大幫助，使我們可以達到精講多練，逐步實現教師指導下的學生自主式
學習模式
。
4．結構清晰，循序漸進
由於本書結構清晰，
知識點
明確，循序漸進的內容組織方式非常符合
初學者
的認知
規律
，因此給教師組織
課堂教學
提供了很好的指導。我們按照這本書的內容結構組織教學，取得了學生和
教務處
的一致好評。
5．習題豐富，利於復習
計算機程序設計是一門實踐性很強的課程，因此僅僅通過閱讀教科書或聽課是不可能掌握的，學習程序設計的最重要環節就是實踐。本書每章都附有大量習題，並且有配套的習題解答，非常有利於學生復習鞏固課上所學的知識。也便於教師設計
實驗課
的
教學內容
。

2. 求：C++數值演算法(第2版)中的NR頭文件

在other目錄下。C++開始沒落了，卡耐基梅隆已雹鉛把搜則C++課去掉。世肆棚
演算法還得用C，面向對象用JAVA / C #。

3. c語言誰講的好

最好的就是譚浩強的《C語言程序設計》。書的內容很全面，還有很多生動的例子，比較容易理解衡仿。這應該是最權威的書了吧。
入門書籍：譚浩強主編
清華出版社的
《C語言設計》
提高書籍：《C語言編程寶典》
和
《C語言數值演算法程序大全(第咐指纖二版)》
可以參考網頁：
1000本C/C++電子書專逗攔題下載

4. c語言實例的書籍

Cambridge - Numerical Recipes in C》這本書的中文版叫做《c語言數值演算法程序大全(第二版)》裡面基本上囊括了所有的數值演算法

C++primer

C++編程思想第二版上下兩卷

以上兩本只是入門一下

《C++ 語言命令詳解(第二版)》這本書絕對必備裡麵包含了所有的c語言函數

《MFC類庫參考手冊 (PDF,全四冊)》這本作為單純C++向MFC的過度也應該必備

我一般都使用MFC裡面的類但是不少都推薦STL，所以推薦你看一下STL方面的書（但是如果你和我一樣不是學這個專業的，只是專業方面需要編一些小應用軟體推薦你只學MFC）

stl推薦你看一下《STL入門教程》這是一本.chm的書，裡面的內容可以實時更新，囊括了所有的stl信息。

以上的書都可以從web 迅雷里下載到。

我的郵箱[email protected]

至於實例的書我覺得都沒什麼用，因為都太大路化了，不能解決實際問題，建議你就在網路知道里搜C++，然後看別的網友在答疑時提的問題和解決方法，效果非常好，然後試著完成一些簡單小任務，賺點分，提高很快，我個人就是從給人編解一元方程地程序開始，一直到現在可以編一些稍微復雜一點的演算法。

5. 求C語言高手

Numerical Recipes in C
一書及所附程序，有完整程序。不過我封裝了它的C++版本，可以對但參數或多參數求極值，完整的頭文件為：

#ifndef __OPTIMIZATION_H__
#define __OPTIMIZATION_H__

//////////////////鄭戚////////////////////////////////////////////////////////
// class TOptimization
//
// $ 求函數一個或多個參數的最小值
//
// 該類默認對一個參數優化，一般只要輸入優化參數數目
// 優化目標函數就可以使用。
//
// ...主要代碼來自：
// Numerical Recipes in C++
// The Art of Scientific Computing
// Second Edition
// William H. Press Saul A. Teukolsky
// William T. Vetterling Brian P. Flannery
//
// 中譯本：
// C++ 數值演算法(第二版) 胡健偉 趙志勇 薛運華 等譯
// 電子工業出版社 北京游碼 (2005)
//
// Author: Jian Feng
// Email: [email protected]
// Dec. 9, 2006
//
//////////////////////////////////////////////////////////////////////////
//
// 輸入函數：
//
// @MaxIterationStep: 最大迭代次數， 默認 1000
// @ParameterNumbers: 優化參數數目， 默認 1
// @InitMatrix: 初始化矩陣參數(N*N)， 默認
// @Tolerance: 容許公差， 默認 1E-7
//
// 執行函數：
//
// @ExecutePowell: 利用powell方法進行多參數優化
// @ExecuteBrent: 利用brent方法進行單參數優化
//
// 輸出函數：
//
// @OptimizatedParameters: 優化結果數據
// @ObjectiveFunctionValue: 目標函數在優化值處的值
//
// 使用示例：
//
// 1. 單參數
// double objfun(double a){
// double sum = 0;
// for(int i = 0; i < DataPoints; ++i)
// sum += SQR(Exps[i] - Theo(a));
// }
// double value
// TOptimization opt;
// if(opt.ExecuteBrent(objfun, -10, -1)) opt.OptimizatedParameters(&value);
//
// 2. 多參數
// double objfun(double *a){
// double sum = 0;
// for(int i = 0; i < DataPoints; ++i)
// sum += SQR(Exps[i] - Theo(a));
// }
// double value[3]
// TOptimization opt(3);
// double ival[3] = ;
// if(opt.ExecutePowell(objfun, ival)) opt.OptimizatedParameters(value);
//
namespace{
static int ncom; //公用變數
static double *pcom_p; //公用變數
static double *xicom_p; //公用變數
static double (*nrfunc)(double*); //公用函數指針
}

class TOptimization
{
private:
typedef double (*Reff)(double *);
typedef double (*Ptrf)(double );

public:
TOptimization(int n = 1);
~TOptimization()

//主要方法
void ParameterNumbers(int n)

//喊磨陵利用powell方法對一個或多個參數優化
bool ExecutePowell(Reff obj, double *a = 0);

//利用brent方法對一個參數優化，需給出參數所在的區間
bool ExecuteBrent(Ptrf obj, double vFrom = 0, double vTo = 1);

void OptimizatedParameters(double *a)

void OptimizatedParameters(double &a)

//void OptimizatedParameters(double *a){
// if(method) for(int i=0; i<num; ++i) a[i]=coef[i];
// else *a = vmin;
//}

//其它方法
void InitMatrix(double **m)
{
for(int i=0; i<num; ++i)
for(int j = 0; j<num; ++j)
matx[i][j]=m[i][j];
setm = true;
}

void MaxIterationStep(int s)

void Tolerance(double eps)

double ObjectiveFunctionValue()const

private:

double brent(double ax, double bx, double cx, Ptrf f, double tol, double &xmin, int &flag);
void mnbrak(double &ax, double &bx, double &cx, double &fa, double &fb, double &fc, Ptrf func);
void linmin(double *p, double *xi, double &fret, Reff func);
bool powell(double *p, double **xi, double ftol, int &iter, double &fret, Reff func);

void shft2(double &a, double &b, const double c)

void shft3(double &a, double &b, double &c, const double d)

double SQR(double x)

void SWAP(double &a, double &b)

double SIGN(const double &a, const double &b)

double MAX(const double &a, const double &b)

void AllocateMemory();

void FreeMemory();

static double f1dim(double x)
{
int j;
double *xt = new double [ncom];
//Vec_Dp &pcom=*pcom_p,&xicom=*xicom_p;
double *pcom = pcom_p, *xicom = xicom_p;
for (j=0;j<ncom;j++)
xt[j]=pcom[j]+x*xicom[j];
//delete []xt;
double val = nrfunc(xt);
delete []xt;
return val;
}

bool setm; //是否設置優化方向初始矩陣

int num; //優化參數
int ITMAX; //最大迭代數
int iter; //實際迭代步數
int method; //優化方法 0: 1-D brent, 2: M-D Powell

double vmin; //一維優化參數
double ftol; //容許差
double fret; //目標函數值

double *coef; //多維優化參數值
double **matx; //多維優化參數方向的初始值

};

//////////////////////////////////////////////////////////////////////////

inline TOptimization::TOptimization(int n )
{
num = n;
ftol = 1e-7;
ITMAX = 1000;
iter = 0;
fret = 0.;
vmin = 0.;
method = 0;
setm = false;

AllocateMemory();
}

inline void TOptimization::AllocateMemory()
{
pcom_p = new double [num];
xicom_p = new double [num];
coef = new double [num];
matx = new double *[num];
for(int i = 0; i < num; ++i)
{
coef[i] = 0.;
matx[i] = new double [num];
for(int j = 0; j < num; ++j)
matx[i][j]=(i == j ? 1.0 : 0.0);
}
}

inline void TOptimization::FreeMemory()
{
for(int i = 0; i < num; ++i)
{
delete []matx[i];
}
delete []matx;
delete []pcom_p;
delete []xicom_p;
delete []coef;
}

inline bool TOptimization::ExecutePowell(Reff obj, double *a)
{
method = 1;
if(a)
for(int i = 0; i < num; ++i) coef[i] = a[i];
return powell(coef, matx, ftol, iter, fret, obj);
}

inline bool TOptimization::ExecuteBrent(Ptrf obj, double vFrom, double vTo)
{
method = 0;
int flag;
double cx, fa, fb, fc;
mnbrak(vFrom,vTo,cx,fa,fb,fc,obj);
fret = brent(vFrom,vTo,cx,obj, ftol,vmin, flag);
return flag ? true : false;
}

inline void TOptimization::mnbrak(double &ax, double &bx, double &cx, double &fa,
double &fb, double &fc, Ptrf func)
{
const double GOLD=1.618034,GLIMIT=100.0,TINY=1.0e-20;
double ulim,u,r,q,fu;

fa=func(ax);
fb=func(bx);
if (fb > fa) {
SWAP(ax,bx);
SWAP(fb,fa);
}
cx=bx+GOLD*(bx-ax);
fc=func(cx);
while (fb > fc) {
r=(bx-ax)*(fb-fc);
q=(bx-cx)*(fb-fa);
u=bx-((bx-cx)*q-(bx-ax)*r)/
(2.0*SIGN(MAX(fabs(q-r),TINY),q-r));
ulim=bx+GLIMIT*(cx-bx);
if ((bx-u)*(u-cx) > 0.0) {
fu=func(u);
if (fu < fc) {
ax=bx;
bx=u;
fa=fb;
fb=fu;
return;
} else if (fu > fb) {
cx=u;
fc=fu;
return;
}
u=cx+GOLD*(cx-bx);
fu=func(u);
} else if ((cx-u)*(u-ulim) > 0.0) {
fu=func(u);
if (fu < fc) {
shft3(bx,cx,u,cx+GOLD*(cx-bx));
shft3(fb,fc,fu,func(u));
}
} else if ((u-ulim)*(ulim-cx) >= 0.0) {
u=ulim;
fu=func(u);
} else {
u=cx+GOLD*(cx-bx);
fu=func(u);
}
shft3(ax,bx,cx,u);
shft3(fa,fb,fc,fu);
}
}

inline double TOptimization::brent(double ax, double bx, double cx,
Ptrf f, double tol, double &xmin, int &flag)
{
flag = 1;
const double CGOLD=0.3819660;
const double ZEPS=1.0e-20;
int iter;
double a,b,d=0.0,etemp,fu,fv,fw,fx;
double p,q,r,tol1,tol2,u,v,w,x,xm;
double e=0.0;

a=(ax < cx ? ax : cx);
b=(ax > cx ? ax : cx);
x=w=v=bx;
fw=fv=fx=f(x);
for (iter=0;iter<ITMAX;iter++) {
xm=0.5*(a+b);
tol2=2.0*(tol1=tol*fabs(x)+ZEPS);
if (fabs(x-xm) <= (tol2-0.5*(b-a))) {
xmin=x;
return fx;
}
if (fabs(e) > tol1) {
r=(x-w)*(fx-fv);
q=(x-v)*(fx-fw);
p=(x-v)*q-(x-w)*r;
q=2.0*(q-r);
if (q > 0.0) p = -p;
q=fabs(q);
etemp=e;
e=d;
if (fabs(p) >= fabs(0.5*q*etemp) || p <= q*(a-x) || p >= q*(b-x))
d=CGOLD*(e=(x >= xm ? a-x : b-x));
else {
d=p/q;
u=x+d;
if (u-a < tol2 || b-u < tol2)
d=SIGN(tol1,xm-x);
}
} else {
d=CGOLD*(e=(x >= xm ? a-x : b-x));
}
u=(fabs(d) >= tol1 ? x+d : x+SIGN(tol1,d));
fu=f(u);
if (fu <= fx) {
if (u >= x) a=x; else b=x;
shft3(v,w,x,u);
shft3(fv,fw,fx,fu);
} else {
if (u < x) a=u; else b=u;
if (fu <= fw || w == x) {
v=w;
w=u;
fv=fw;
fw=fu;
} else if (fu <= fv || v == x || v == w) {
v=u;
fv=fu;
}
}
}
flag = 0;
xmin=x;
return fx;
}

inline void TOptimization::linmin(double *p, double *xi, double &fret, Reff func)
{
int j, flag;
const double TOL=1.0e-8;
double xx,xmin,fx,fb,fa,bx,ax;

int n=num;
ncom=n;
//pcom_p=new Vec_Dp(n);
//xicom_p=new Vec_Dp(n);
nrfunc=func;
//Vec_Dp &pcom=*pcom_p,&xicom=*xicom_p;
double *pcom = pcom_p, *xicom = xicom_p;
for (j=0;j<n;j++) {
pcom[j]=p[j];
xicom[j]=xi[j];
}
ax=0.0;
xx=1.0;
mnbrak(ax,xx,bx,fa,fx,fb,f1dim);
fret=brent(ax,xx,bx,f1dim,TOL,xmin, flag);
for (j=0;j<n;j++) {
xi[j] *= xmin;
p[j] += xi[j];
}
//delete xicom_p;
//delete pcom_p;
}

inline bool TOptimization::powell(double *p, double **xi, double ftol, int &iter,
double &fret, Reff func)
{
const int ITMAX=500;
const double TINY=1.0e-20;
int i,j,ibig;
double del,fp,fptt,t;

int n=num;
//Vec_Dp pt(n),ptt(n),xit(n);
double *pt, *ptt, *xit;
for(i = 0; i < n; ++i)
{
pt = new double [n];
ptt = new double [n];
xit = new double [n];
}
fret=func(p);
for (j=0;j<n;j++) pt[j]=p[j];
for (iter=0;;++iter) {
fp=fret;
ibig=0;
del=0.0;
for (i=0;i<n;i++) {
for (j=0;j<n;j++) xit[j]=xi[j][i];
fptt=fret;
linmin(p,xit,fret,func);
if (fptt-fret > del) {
del=fptt-fret;
ibig=i+1;
}
}
if (2.0*(fp-fret) <= ftol*(fabs(fp)+fabs(fret))+TINY) {
delete []pt;
delete []ptt;
delete []xit;
return true;
}
if (iter == ITMAX)
{
delete []pt;
delete []ptt;
delete []xit;
return false;
//cerr<<"powell exceeding maximum iterations.";
}
for (j=0;j<n;j++) {
ptt[j]=2.0*p[j]-pt[j];
xit[j]=p[j]-pt[j];
pt[j]=p[j];
}
fptt=func(ptt);
if (fptt < fp) {
t=2.0*(fp-2.0*fret+fptt)*SQR(fp-fret-del)-del*SQR(fp-fptt);
if (t < 0.0) {
linmin(p,xit,fret,func);
for (j=0;j<n;j++) {
xi[j][ibig-1]=xi[j][n-1];
xi[j][n-1]=xit[j];
}
}
}
}
}

#endif
另外,站長團上有產品團購,便宜有保證