[分享]插值软件langrang - 数学建模社区-数学中国

软件名称：EXCEL自定义插值函数插值计算数值计算版本号： 04y09m28 分类：工程设计应用性质：免费软件使用说明：

人们对EXCEL普遍熟悉的功能是表图的处理，不太知道其在工程计算(如锅炉设计计算)中的应用。复杂的工程计算常常用专业编程语言（Fortran、C、Pascal 等）来编制计算程序解决，用专业编程语言编制工程计算程序往往有下面二个缺点： 1）编程语言专业性强，一般工程技术人员难以掌握，由这些专业编程语言编制的计算应用程序的维护、修改、升级都比较困难。

2）由专业编程语言编制的工程计算应用程序人机界面不友好，常常需要复杂的输入前、输出后处理。

EXCEL每一个单元格就是一个电子表格，很容易进行一般的加、减、乘、除、乘方、开方，而三角函数、指数函数在EXCEL中可以直接引用内部函数。用EXCEL编制一般的工程计算程序还需解决的有以下两个问题：（1）循环计算，（2）表、单曲线、曲线组的查找（如：锅炉设计计算中的焓值）。对于问题（1）循环计算，EXCEL在工具菜单中提供了两个命令：单变量求解和规划求解，利用这两条命令很容易解决问题（1）。对于问题（2）表、曲线的查找，EXCEL没有提供现成的函数，但也可用VLOOKUP、MATCH、IF、OFFSET等函数的组合勉强近视解决，本文重点介绍表、曲线的查找自定义函数的定义及使用。为了更好地解决曲线查找的问题，应用C++程序设计语言，用拉格朗日插值计算法在EXCEL中建立了自定义函数，单曲线插值函数TWLQ(变量，"带路径的保存数据的文件名")，曲线组插值函数THLQ（变量1，变量2，"带路径的保存数据的文件名")。单曲线插值函数、曲线组插值函数的"带路径的保存数据的文件"包含着特定对映表、曲线的信息和计算精度的要求 (文件为Notepad编辑的txt文件) 。单曲线lagrange插值函数：double twlq(double x,char* filename)； double twlx(double q,char* filename)；曲线组lagrange插值函数： double thlq(double x,double y,char* filename); double thlx(double y,double q,char* filename); double thly(double x,double q,char* filename);。

例：单曲线插值函数 "带路径的保存数据的文件"结构如下： @ Description @ n， nsel； x[0]，x[1]， x[2]，··, x[n-2]，x[n-1]； q[0]，q[1]， q[2]，··, q[n-2]，q[n-1]； MinX=0.7,MaxX=0.9,OverRangeAlm=1,X=电压,XUnit=mv,Q=电流,QUnit=mA

注解： Description:用户自定义描述字符串（Description中不可有@符号）； n: 总插值点个数； nsel：实际参与插值计算的插值点个数； MinX=0.7,MaxX=0.9 取值范围； OverRangeAlm=1 越限报警 1:报， 0：不报; X=电压,XUnit=mv,变量名称，单位。

****结论： l）图形化界面的插值函数数据文件生成器 LCZMaker 方便快捷生成单曲线或曲线组插值函数数据文件。 2)应用EXCEL自定义插值函数，在EXCEL中进行工程计算编程极为便利，比专业编程语言程序设计更易学易用、直观明了，用EXCEL编制的工程计算应用程序更易维护、修改、升级。 3） EXCEL本身长于表格制作，在EXCEL中进行工程计算编程人机界面友好，输入前、输出后处理方便简单。 4）在某大型锅炉厂电站锅炉性能设计计算中已显神力。

附含壁温计算,强度计算,热电偶/阻,水阻力,烟气阻力,蒸汽性质等现成数据。

9 s% S% [- K; C/ x2 c2 c
/* TODO: Lagrange interpolating
- h$ m" L5 z* n& ^* o7 M2 c
*8 v$ c4 {1 A: w% l
* For example, if lg2.71 = 0.4330, lg2.72 = 0.4346, then lg2.718 = ?
& _# Y% I3 L" [2 H: _! }
* In this situation, it could be solved via lagrange interpolating8 Y4 K+ }/ R2 |5 P# H% n: Q
*' L' ~6 a4 L+ _/ x. f0 v9 L
* */% P$ s) K, V' v6 \4 Y% Q
. s3 L9 C0 G& s2 A! @
#include <stdio.h>
1 f" ~) S5 K( y0 T; @: D2 x2 r6 d9 ]
#include <stdlib.h># A+ C( ?2 |" o' |( d& ~6 u7 H3 G
#include <string.h>3 x# j+ V) m% V5 }2 ?! C
8 s. l1 V% h# E
#define DEBUG 0
+ `$ y. @' x/ c' M( p, p
+ ? {, C# l: s2 S6 ~ m% D$ x; R
static float m_p = 0.5635;3 ^+ z( X/ G, a6 }! [6 e f/ E
static char *m_xi = NULL;# @8 u! K h6 p2 @/ k$ U7 n
static char *m_yi = NULL;
) \7 \, _5 A; h" f7 c3 H
static float m_arr[] = {};, j' f( x! i }4 p; X. ~
static unsigned int m_n = 0;
8 g) s5 Z) ]6 t
4 M* z( m; F# g9 v. L) c$ d
static void m_lagrange_interpolating_usage();/ a+ C5 T T5 p, \- r
static int m_lagrange_interpolating_set_n_arr();
' H2 L& V5 x2 `7 M+ L
static float m_lagrange_interpolating();& a) x* c+ g1 ?3 ]3 C( z3 T
, U. K4 a/ f3 v- e
static void ! T' s& q% A2 S0 h( U1 B. {5 Q" U
m_lagrange_interpolating_usage()
; K) c. F2 o" w. t9 i6 I( @4 k
{" \1 u$ ^" t7 G7 A
printf("Lagrange Interpolating Usage:\n");
9 H* D% C& {" h: i, e9 B
printf("bin/li -p ** -x ** -y **\n");( k E' l! C* p: ?# R; @
printf("-p 0.5635\n");
0 W) J% t x6 \5 ~* y
printf("-x 0.56160,0.56280,0.56401,0.56521\n");, e/ ?, |# }7 ^+ W' y. ~5 |
printf("-y 0.82741,0.82659,0.82577,0.82495\n");
$ W; k* h: h" S
}
; P0 m0 ?' ~) W& s
- m+ P; s% b0 ?
static int 9 X) g" h: W2 E, J! h" X
m_lagrange_interpolating_set_n_arr()
7 t- g0 G9 W. e( `
{
! D' }7 j' Y1 D. s; z& G. ~, r( a2 i
int xi_n = 0;
3 Q9 A6 i$ y+ ~) i- \6 z
int yi_n = 0;
$ X3 F. }! S' J% y% w
int n = 0;
7 E0 U% L- b- ~+ ]/ v+ l2 {! Q( C
char *token = NULL;
( x. g/ t; @8 M! e
const char *delim = ",";% z% X6 t d' K* h& X& T% |$ P" a
+ _( B% y4 E. }1 n
token = strtok(m_xi, delim);
) f& y; j. ?7 u8 ?" R" N( @! v+ X
while (token)
! u# r& Q4 ^8 X
{, o3 r( g/ Y" }: i! g
xi_n++;
9 F6 }7 r( T* R) m
n++;# {9 l1 Y' T$ d6 Q- m: q8 j
m_arr[n] = (float) atof(token);! ~4 ~! Y8 F, G) x) e9 r* \
token = strtok(NULL, delim);
) h I7 ]5 h. v3 Z* Z/ T( O: S
}
6 Q+ v, P( V$ P' e1 |5 g
$ L/ ^ A7 H: k8 `$ H- u& d: q
token = strtok(m_yi, delim);6 Z- v1 ~1 z( O. y& |% E
while (token)# i. R( ?/ ~5 p) G" t
{
/ a; p( I7 P0 _
yi_n++;
6 _8 f2 k. m9 c
n++;+ O' v0 w! O* u8 ~; X: S
m_arr[n] = (float) atof(token);
; t {) P! V3 t$ X; x
token = strtok(NULL, delim);/ W' U3 H$ l3 R) G7 r
}
; I( ?0 j- G- x+ d" ?" j( p( A
5 z+ }$ ^, A- m# S; n
if (xi_n != yi_n)
- m8 ]9 s( z8 z9 U0 W c. t
{' }; V# N D! z' r" X5 g
return 0;
$ j+ _6 O. ]( J4 x( j
}
2 F( r3 P4 u& M) r& F f8 s# v
q1 n- N- R2 w
m_n = xi_n = yi_n;8 Y, }* Y! j& Q1 {
% w: @, x. \! J- ?* r, Z* c
return 1;
3 A" N( t9 I9 q* l% ]! a
}) \# y1 S; C2 ?0 [8 ?( }
2 m9 ]5 R7 A. `& j
static float
1 l; ~- a1 g- K3 B: N# {9 I
m_lagrange_interpolating() 9 q0 [. `3 D, ]5 U- x( X' Z3 W& \% n
{4 ]. H: G" D( P1 [) e5 |1 i4 \; C
float l = 0.00000;
6 u3 [( f8 e; }9 z/ P- G; `
float li;! Z& x8 w! J% y5 ^! x* v
int i;+ q6 W: F$ t0 T2 V0 p1 l( U
int j;
- f+ m& `% T# \3 Q6 Y
; x; Z4 G2 b; X8 y+ m
#if DEBUG
1 e2 b( k" L; ?" S" v$ W
printf("DEBUG at %d: enable debug mode\n", __LINE__);& [& D( ?* J t8 \7 l* b( k7 o
unsigned int m_n = 3;+ a) u/ W% g& h/ r, X
float m_p = 0.5635;5 ^5 @* A2 O2 N0 p, c
float m_x[] = {0.56160, 0.56280, 0.56401, 0.56521};4 J3 M6 C8 W3 f9 t
float m_y[] = {0.82741, 0.82659, 0.82577, 0.82495};
2 n7 u d" k. m# F' W0 X
! `1 x4 y: s0 t, [
for (i = 0; i < m_n; i++)
8 D( v7 K; i; P) F' P1 A
{
2 c7 U0 {. _8 v" v
li = 1.0000000;9 \- I! G5 C: X
for (j = 0; j < m_n; j++)
- i# |# P% Z$ V; I# i. R
{; A" Q' ], Y& I* Q
if (j != i)
( D' B$ Y9 n# }
{
* _$ r5 m0 e) u" J; A6 O& h O
li = li * (m_p - m_x[j]) / (m_x[i] - m_x[j]);3 e4 G$ S- `) [
}
* x9 t/ F9 ]* v9 q, l8 d
}; \/ a: {. m$ f$ K
l = l + li * m_y[i];
4 M, M- Q1 N& R; D1 c' F2 u
}5 U3 p. N/ k+ ]1 g2 q( H+ m& N
#else* b6 A2 e) u, J% N0 Q8 U% G
if (!m_lagrange_interpolating_set_n_arr()) 0 x) f, Q% n+ G
{
7 w0 y5 I) C! U: E
printf("Error: xi and yi counter is diff\n");# E% K& g4 b2 c
+ m( k% s [# _$ ~. p7 Z, G
return 0;, a/ O" h) p3 C
}; B: v4 \ j& w
7 r, \1 n' E0 g& x- ]# ^
for (i = 0; i < m_n; i++) * h7 z! u9 i/ P# }4 E7 v
{
) d# p; Y0 r8 N) k) q3 ^0 c& X. k
li = 1.0000000;' f+ l; F* L: b" l) y
for (j = 0; j < m_n; j++)
0 V+ x& D; J4 L
{
) ?( v9 y$ r6 t
if (j != i)
1 C( b* U) H3 [; I. E0 G2 d' S
{7 d7 o5 Y- H4 g K. I3 Q
li = li * (m_p - m_arr[j + 1]) / (m_arr[i + 1] - m_arr[j + 1]);
: X" ^: l. Z) p0 r
}, z5 a5 G. m1 u8 b
}
; u4 I/ m$ y' D: {! Q* p3 P
l = l + li * m_arr[i + m_n + 1];" q$ A# R- ]" \$ C6 [
}
& Y9 V5 }! j S. e4 G+ r
#endif
5 B' L) f4 r. X! K" o0 J) y H
9 `; V1 Z% U( e" [( ~) a6 J% F
return l;
- ~/ W* W6 F5 r
}# Y* E7 c& y9 ]2 i
' b0 c0 m8 C% p* I% Y
int
: K$ p1 y4 h: R# k1 N% n4 A
main(int argc, char **argv)
5 `8 m8 G' |' y2 ~0 G0 D9 z
{: O* ~% X0 [; ]0 f
int c;; D6 q6 v E" R) B5 E
extern char *optarg;
# t$ U. o8 `# [3 C
float res;. H! N8 a1 N5 O7 }1 v9 w% o5 x" a
8 R. [$ U3 o! j" x/ |8 g# b
if (argc < 2) ( N6 \" l7 B, n( C8 }6 p3 f) Z
{
' y/ D8 C8 a% |, q
m_lagrange_interpolating_usage();
" A% _* V2 _1 i* _# |
8 s" E! i# T3 o% ~) ]
return -1;6 u: ]7 f+ W3 Q
}% w6 W" X5 }; L: V+ P
* g+ y& U7 z* ~ i
while ((c = getopt(argc, argv, "p:x:y:")) != -1)
4 ?% a# L8 ]" S3 r8 t
{! V8 x3 w2 B! Z& @% \4 z* E
switch (c) + L/ {4 d* P; [' N6 F: Y V' ]
{* X, Q: `) i# w1 A [3 L p) h
case 'p':+ K- z+ M1 u6 I5 z
m_p = (float) atof(optarg);
! s" o$ b/ V2 ?* ]/ Q0 N
case 'x':/ u9 j. _0 z& E2 C7 q
m_xi = optarg;
8 g8 f) }5 w, u
break;5 Z2 ~) l+ c s# I r) s
case 'y':
/ s/ f! J' R8 M- Y7 x. R6 H$ E) L
m_yi = optarg;, K. v8 M; a) p+ M) e9 p8 C* l' D
break;
8 Z& F" y) \2 I- a8 n
}
; e t; X. |( v" m# j
}
- x2 }& }. [7 U
% `/ X5 |# R# y; J+ k0 }
res = m_lagrange_interpolating();
d+ Q: {9 [) D+ h- F& s
printf("Lagrange interpolating with %.4f result is %.7f\n", m_p, res);
0 Y; k5 q7 y2 w3 @( `: W
1 `0 B0 A, z* ]+ ~& Z& G5 p9 Y
return 0;
0 A! S& z; M8 m) j1 E* N( H0 u) H
}
% ]5 Z; j7 h, y. D% z8 R' C

复制代码