[分享]插值软件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）在某大型锅炉厂电站锅炉性能设计计算中已显神力。

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

/ M! W/ X" u6 X @4 y
/* TODO: Lagrange interpolating
2 M9 m# B& a3 ^8 @+ j
*
$ a- W4 Q% b: h
* For example, if lg2.71 = 0.4330, lg2.72 = 0.4346, then lg2.718 = ?
' E' ?& q: n' S* V; s) ?- b: }* A
* In this situation, it could be solved via lagrange interpolating
8 l3 ?& ~. J* j% L
*
& A) ]( E2 n* c) |/ ^: U
* */ _4 ~' @6 I4 c7 v1 W8 R( N2 d
#include <stdio.h>2 C7 L1 Q6 {" i% s( ~ G, }. w
#include <stdlib.h>5 f6 Q2 A) x* k/ U9 s% `
#include <string.h>
: J+ V: r Q* P7 _
1 c$ c% u1 \3 I# p9 x6 {% A. l
#define DEBUG 0
3 [3 Q9 ?" K+ \9 t- f7 k" g
9 U, }7 O$ t* n- F$ E1 ^# H
static float m_p = 0.5635;" j' \( w; h% N$ U
static char *m_xi = NULL;/ `/ ^9 s! c$ P/ R' d
static char *m_yi = NULL;. K/ ?& K5 H- F& H
static float m_arr[] = {};: |% F6 W, f! O6 ^; O" |- E) A
static unsigned int m_n = 0;
! V- {# C }: L0 q+ j4 u
0 f! t; J5 F* g0 Z
static void m_lagrange_interpolating_usage();& F2 p3 l) |) `$ S- o
static int m_lagrange_interpolating_set_n_arr();
6 a9 _3 y5 ]0 Z) J4 _0 r" n
static float m_lagrange_interpolating();# \$ g, k) l8 I% E! ]
( L, @# n) T" |, o! N, G6 ?
static void 6 E( E! S4 v3 _+ t) {* K d
m_lagrange_interpolating_usage()
* }3 p9 P3 t0 L2 u
{
! _1 @& B! j$ j$ x# H' b
printf("Lagrange Interpolating Usage:\n");$ L* f& @+ w( P5 M- u6 ~
printf("bin/li -p ** -x ** -y **\n");
! B1 r {9 O( \
printf("-p 0.5635\n");
. z8 {# ^4 k" [
printf("-x 0.56160,0.56280,0.56401,0.56521\n");7 ], ~& O# v- x3 v8 s( F+ ^" `
printf("-y 0.82741,0.82659,0.82577,0.82495\n");
' O* o: C8 `+ T1 G
}6 a9 M4 l) a3 G" u( Z
! a4 L* [8 e2 [
static int ( a4 N7 }2 }# _% V6 z
m_lagrange_interpolating_set_n_arr() / R6 t: Q0 \% w
{
6 H9 m9 ]9 y5 `# j* W
int xi_n = 0;
4 B% a$ j) i/ |" v3 q' F% A
int yi_n = 0;1 H+ X; p* W+ u4 n2 i8 e
int n = 0;
+ t7 z/ M! L6 o0 H6 ] i
char *token = NULL;
# H5 K# V \; Z# R7 Z& z& b
const char *delim = ",";
& f- K$ G5 ^) m9 a2 c: U4 u: n
7 ?5 B6 O$ [. T& m7 O1 ~1 X U
token = strtok(m_xi, delim);
! F& ?9 ?6 y" b& o# x
while (token)
* y" g, |7 L, T& F$ ~, G6 v
{
( E" T, g" e& e( I; G
xi_n++;
$ F( o" e# r! U6 K
n++;
* y6 g+ {! a$ i( c
m_arr[n] = (float) atof(token);
9 V: k% r6 c5 j# \/ \% t
token = strtok(NULL, delim);1 N( ? w) k5 h: d+ x% h' R
}
K- p4 u2 `/ M' q" v' R: C2 G
, ? D' X, L+ Q1 G) G% _3 n" v+ D
token = strtok(m_yi, delim);, _/ |$ Q N. j
while (token)1 ~$ W: T, Q4 G, c) x. j
{% e1 l9 D% _" b6 i% \
yi_n++;4 J: f9 @5 Y3 _; t& n
n++;- l0 ^" R; x$ T) b; M
m_arr[n] = (float) atof(token);: O2 g! r5 ~4 a# v$ A& R9 A
token = strtok(NULL, delim);
# O {8 N* j% L, D8 j) E
}% f) z* F: q$ n& U: l. ]: b; _
5 w! ]$ }5 m; P% e. y
if (xi_n != yi_n) ( e5 T D; N9 O0 T& I O: G7 |- |
{1 P, M# A, t% s1 [6 ]9 Z; W8 h! a
return 0;
* o% ]) y4 L2 T, c9 n
}5 l' f$ s L, L9 N5 _& V! l4 n
k* `+ n; [4 B4 a
m_n = xi_n = yi_n;3 [3 N5 I7 O4 i6 J5 t1 Q
; s( e, |6 O, {" U* F1 e! ^5 g
return 1;
# u5 ^; O6 a% c! ^! Y
}
! y; x1 A! j1 q! B+ Y4 b
) D9 o8 D1 `0 E h2 L
static float
1 J8 t$ r' u, U
m_lagrange_interpolating() ( d8 e& u/ B: T$ P! j- g
{$ D& L" C) `+ W E( I
float l = 0.00000;
' |* q, _: H8 c$ h" J' d; ^! `
float li;( n5 n. M/ a4 q1 {
int i;: p: [, N/ U+ ^/ ^5 r' @4 k
int j;8 m, |3 T6 q9 J) b1 v. a' Y
, d( {0 L! L5 ^( N7 D/ S; ^7 }' T
#if DEBUG
2 C- b# O8 z% F* e) I1 D
printf("DEBUG at %d: enable debug mode\n", __LINE__);# D% k8 B0 b/ k. @. e& T7 K
unsigned int m_n = 3;
0 K: _4 j! D: \
float m_p = 0.5635;
; R8 |6 ]9 E( y3 a% L& U3 U
float m_x[] = {0.56160, 0.56280, 0.56401, 0.56521};
+ a& n! ?+ R! i
float m_y[] = {0.82741, 0.82659, 0.82577, 0.82495};
& Q$ L; h3 T1 M i0 t/ H4 \
! L* S+ g/ {) `! @: @+ ]
for (i = 0; i < m_n; i++)6 U- D+ k) ?- ~* q
{3 i$ }& P' y' A9 T5 Z, \
li = 1.0000000;/ {6 n4 f6 Q+ a" u, v2 f
for (j = 0; j < m_n; j++)
3 f9 C! r/ d+ O3 k' T1 k
{7 l+ L$ {' p8 [2 A) W5 Z
if (j != i). n Q/ B% S! u0 t
{
$ | U6 t, c! v% i: ]
li = li * (m_p - m_x[j]) / (m_x[i] - m_x[j]);
5 b/ O7 j- J7 b( [. T# V: X
}
, M% @' b/ s7 {7 L: I
}
! V! m2 v6 N7 Y- q; h, ]
l = l + li * m_y[i];
1 v" ~ O/ `0 r2 f+ t; V7 S
}+ P2 q; z q9 O* {1 d. C
#else; ], v! N0 K2 q- L
if (!m_lagrange_interpolating_set_n_arr()) 8 Q/ k3 D( a H! x/ |
{) _2 w7 @3 N$ C, v; J. c
printf("Error: xi and yi counter is diff\n");
$ W+ E5 Q* H6 E A
- m- M/ j- w9 O4 q! [6 _7 b- \0 _
return 0;
& ?: V6 b8 H7 ?4 U
}. a3 m, `- _& Y9 S6 G7 {7 d+ x; r
9 A& a5 w& e. X/ w8 S/ A
for (i = 0; i < m_n; i++) & \0 D$ m( l) O) d) R3 H4 z
{2 ~9 c% {7 D! m7 G: b
li = 1.0000000;
$ u& H% F7 X/ {% I1 T- z$ p- S
for (j = 0; j < m_n; j++)
2 b& K- k) R: V) ^/ G# k1 J7 x. h
{' F! B7 _5 r' o# y! n2 ?8 H
if (j != i) ( m2 d2 T$ X' [& t( i) s( w8 [
{9 j+ U9 l! ^: \2 D0 K/ H+ B
li = li * (m_p - m_arr[j + 1]) / (m_arr[i + 1] - m_arr[j + 1]);) C1 s" Q0 l: B& j% D$ Y- c# I
}6 i* a9 k$ s- J# S0 O0 l5 z* N" u1 l
}0 \' M: i1 e) n/ N- h; T
l = l + li * m_arr[i + m_n + 1];
7 d. a/ a% T0 h, h! s3 n
}
8 \% o5 u9 J6 G: T- q" t H( A
#endif
! e: y, t; P* b% B" [( Z' E/ N. m
4 p* B/ B9 R# L; F0 Y: g( Y
return l;& {4 V# W6 C: _& D9 U0 y
}; b7 q' d( J8 H" N. M
+ ~* H1 \3 r5 `$ U+ ^
int 4 \2 U% f7 f; W7 T! @: i
main(int argc, char **argv)
- g( [3 J) ]) b, w$ c" _
{
& i w( N# u/ H% F
int c;$ y" e$ _9 ~+ ~3 Z2 z) f; Y
extern char *optarg;5 J$ a8 M9 e- J. t+ f8 U0 j
float res;
3 P" H7 F F1 S, G$ ?
& o6 w) x& u5 G4 O3 {
if (argc < 2)
) b2 F K ?( P, O( c; y* e+ e" g
{+ Z* W8 p B& [" q9 I; c4 h
m_lagrange_interpolating_usage();
- y) i1 x" I# Y* E
) D- m1 d+ c) \) E
return -1;
, a& f! R( L3 _6 D t
}& t3 L- x% x* o' ~ W2 N7 d
while ((c = getopt(argc, argv, "p:x:y:")) != -1)
/ O- x: I* w& K
{
, G6 Y/ V% z! Q9 Z
switch (c) ' U$ M* F) a, D$ c9 k" b
{' a& l0 w& d* n) r! g6 I7 j4 V
case 'p':
: e _1 C. z; O: d" C* I$ i4 c
m_p = (float) atof(optarg);
3 V4 `4 Y: |; c4 P, S& H- G
case 'x':; n, M5 r7 e4 I; e9 G9 m+ V
m_xi = optarg;5 _1 K' |/ f( n/ E; @4 R
break;# a! Q' y2 W( m! Z) r5 V
case 'y':
2 |8 ?( ]- v! q1 c0 a
m_yi = optarg;6 z+ |- h& L4 C$ z
break;
, q. \5 x" `3 c9 G% `% |, C
}
5 P7 ^4 a2 ^; P+ k
}% l0 R2 S4 m! X0 l$ ?
# M3 P9 p6 B I- U& x
res = m_lagrange_interpolating();
7 f" G1 B' n& B9 f5 v( x
printf("Lagrange interpolating with %.4f result is %.7f\n", m_p, res);1 _! y3 e5 u6 S* g+ r
8 X& s! m0 p- U# G
return 0;
3 v/ C" w2 z6 Q" m/ b
}5 W( |# f @" g: T8 p

复制代码