[分享]插值软件langrang

ilikenba

软件名称：EXCEL自定义插值函数插值计算数值计算 2 u; q0 E# x& U版本号： 04y09m28 分类： 工程设计应用 性质： 免费软件 使用说明：

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

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

3 e- V5 x. a' Q; P# B

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

f* B; E& o3 A

例：单曲线插值函数 "带路径的保存数据的文件"结构如下： ' Z v; s% i3 v9 ~0 [$ L@ Description @ n， nsel； 8 n8 @" A/ J0 Dx[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

注解： ( z- R2 I" ?" H8 @ Description:用户自定义描述字符串（Description中不可有@符号）； n: 总插值点个数； nsel：实际参与插值计算的插值点个数； 5 l. Z1 S6 A+ N3 b% @ MinX=0.7,MaxX=0.9 取值范围； . s i4 E, b# } OverRangeAlm=1 越限报警 1:报， 0：不报; , S. A/ N' r! R* R X=电压,XUnit=mv,变量名称，单位。

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

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

# o1 ]4 V7 h3 r

ww991616

ft12345

好东西，谢谢斑竹

xiangzhai83

1. # q1 T* q6 Y* W* [- r+ ]
   
2. /* TODO: Lagrange interpolating . l) |$ G$ v\" l5 ?
   
3. *
   2 {2 [( s' O( \. f: S5 M! D6 [4 [
4. * For example, if lg2.71 = 0.4330, lg2.72 = 0.4346, then lg2.718 = ?
   / p# z8 J) x& y9 y' e
5. * In this situation, it could be solved via lagrange interpolating% H6 w1 W# A0 [; E2 A$ s3 @5 z! m
   
6. *4 O  s# M' m/ R8 X2 G
   
7. * */, ~  g) I& r1 L8 v9 D/ O
   
8. 
   & [! N/ M( F5 L& S' K
9. #include <stdio.h>& \+ Y) @; Q8 J( N
   
10. #include <stdlib.h>
    # C( f( e\" X9 z- D/ _
11. #include <string.h>
    8 `: x  D3 L5 a; J' O\" w
12. 
    ) f9 h) g8 G7 q: L! ]
13. #define DEBUG 0
    ( E; j3 H* ~) Q9 D
14. ! b- Q$ a6 y2 z$ v- ]# K
    
15. static float m_p = 0.5635;2 `) L6 W8 v  q* }+ R3 n( J. Z
    
16. static char *m_xi = NULL;
    4 Y3 r5 Y5 b$ x
17. static char *m_yi = NULL;
    & j& w- R( U. y0 g
18. static float m_arr[] = {};
    % P! ^$ J8 u3 q; E$ X. S
19. static unsigned int m_n = 0;2 h# y( `( I: g5 q& X* N- B$ G
    
20. 
    9 s- e: Y4 u. u
21. static void m_lagrange_interpolating_usage();# X. }8 A& u# c- L+ Q4 T
    
22. static int m_lagrange_interpolating_set_n_arr();
    4 C  R& N1 R  Q9 U, T; c\" T. v3 @
23. static float m_lagrange_interpolating();8 o  X4 `0 ~$ w, j4 O( T/ d
    
24. - p. ~4 @- j5 b\" Z$ `( q* G
    
25. static void ! t/ {; \0 x. [+ o; h. {
    
26. m_lagrange_interpolating_usage() % }; v$ w4 v. T1 A* ]- B6 `
    
27. {
    . j7 o( w4 H6 e
28.   printf("Lagrange Interpolating Usage:\n");
    9 E* a8 ~& z8 W+ q) Q, Z
29.   printf("bin/li -p ** -x ** -y **\n");' `; {% i! h0 |- ?( n) m% n
    
30.   printf("-p 0.5635\n");
    : T2 ?$ e5 [4 W' [$ ?4 @
31.   printf("-x 0.56160,0.56280,0.56401,0.56521\n");
    $ l0 Z& F# e0 H, p
32.   printf("-y 0.82741,0.82659,0.82577,0.82495\n");
    ' M. {( T& D( p$ z9 {9 |
33. }
    % {) H1 `1 L' Y1 i& J! F0 [
34. 4 Q' O) J( T* a7 u7 r# p4 j6 L  ~
    
35. static int
    5 x% b& H( g2 [; f% ?/ S
36. m_lagrange_interpolating_set_n_arr()   N) D. t: J) ^$ C
    
37. {% _\" O/ B( ]: O. W
    
38.   int xi_n = 0;, e1 |& Q: F& [/ j! ~\" Y
    
39.   int yi_n = 0;
    , g& \( t) C1 x0 d8 a
40.   int n = 0;/ j. @; K\" `$ v! H( _
    
41.   char *token = NULL;2 F8 ]- _3 L' I
    
42.   const char *delim = ",";- x5 n; t: u# X# v8 C
    
43. 0 Q: J' Z$ H* F1 b& c: f/ K0 s
    
44.   token = strtok(m_xi, delim);% i! Z# E* z5 T. K% Y
    
45.   while (token)0 l1 q2 _) w$ ~0 A
    
46.   {
    ; _, G/ L. p1 @$ c* h! V8 P
47.     xi_n++;  a0 n& j, P5 e$ s/ Y% H: R
    
48.     n++;
    + B) |\" S0 P. Y$ l8 d0 P* f
49.     m_arr[n] = (float) atof(token);( [/ u1 ^7 {6 i, I5 A$ Q
    
50.     token = strtok(NULL, delim);\" B* J\" E+ ?. s2 J! A
    
51.   }( V) N* d0 N7 p\" I
    
52. # B! v3 j1 C& T
    
53.   token = strtok(m_yi, delim);8 {1 ~* K5 O) ?. S5 A1 `* j5 ]' z
    
54.   while (token)( k  B' F* E8 w+ f6 h
    
55.   {
    ( {$ A& E7 u) Y\" l\" b: W( w0 T
56.     yi_n++;  t1 @6 u0 e! c$ m% E\" o) p+ b# a3 c
    
57.     n++;
    2 y4 s( Z& w6 F. Q- |& _8 \% h; Z
58.     m_arr[n] = (float) atof(token);
    2 s3 C7 s# D% m\" A$ `/ i) T\" a* Q
59.     token = strtok(NULL, delim);: ]( o- h5 b! S
    
60.   }0 e1 }3 p9 u, R
    
61.   ; t- F  w; {; X9 r
    
62.   if (xi_n != yi_n)
    # a\" i( Q' ?4 P3 q
63.   {. G\" ]3 V6 n: k8 x\" ~
    
64.     return 0;
    ! [4 a$ D1 ^) u9 W\" K. A$ P
65.   }* q# Z6 r/ f4 B( y# |3 K, O. T3 A
    
66. # j7 ~+ r+ E, @$ `( l( a; m
    
67.   m_n = xi_n = yi_n;
    # Q\" M: `  \/ {( ~2 l! y
68. 
    # R0 L  `5 r! W, m% c
69.   return 1;# ]  Q3 V/ L; {  s4 i) r( f
    
70. }, W0 Q  M. X* }9 L
    
71. # [8 J, {, F! ]0 ^4 r
    
72. static float
    $ h  I4 N( ~$ e/ |
73. m_lagrange_interpolating()
    1 c  w) W7 S; ^9 E+ v\" J
74. {* _# s1 m9 A. I$ Q
    
75.   float l = 0.00000;
    ; M8 ^. ~5 G: j/ ]\" Q# V8 F( F4 y3 g
76.   float li;( @3 \) i; m, \1 ~2 V8 F7 x
    
77.   int i;0 A# @' |6 R4 z6 @, \0 @+ U
    
78.   int j;
    ; v. {2 j; I0 J; a2 k
79. 2 l\" P. U8 O7 E) m) U\" g. [
    
80. #if DEBUG( G2 m2 y- }) N4 W
    
81.   printf("DEBUG at %d: enable debug mode\n", __LINE__);& \, |( H& k& I# l3 }
    
82.   unsigned int m_n = 3;' Z5 h, x/ H+ h- e
    
83.   float m_p = 0.5635;9 Z6 T\" c8 i. F2 |8 f
    
84.   float m_x[] = {0.56160, 0.56280, 0.56401, 0.56521};1 X. ^+ s& ?# w1 L3 Z
    
85.   float m_y[] = {0.82741, 0.82659, 0.82577, 0.82495};
    : E5 I7 F' |0 C- Y
86.   
    3 R) C4 ]; W, f* }( O' J+ d. ?! X
87.   for (i = 0; i < m_n; i++). v5 q$ W\" l$ {' ^: y- _3 i\" z
    
88.   {
    ( `- ^1 f: ]* t, t
89.     li = 1.0000000;5 I6 ?8 Q3 R9 v6 a9 q7 i
    
90.     for (j = 0; j < m_n; j++)
    3 h5 X* a3 r( v2 m+ u: }5 M, C$ Y: u
91.     {
    7 M) Z6 R3 H4 s& N
92.       if (j != i)* K0 Q( W) |4 w/ L' J
    
93.       {8 k/ ]- O1 q7 V
    
94.         li = li * (m_p - m_x[j]) / (m_x[i] - m_x[j]);
    $ }# W\" O  q7 y$ h5 {) i6 L9 \: |
95.       }& V: S8 ~9 f: c$ c* `
    
96.     }
    , Q7 k2 l9 o' r/ X* T
97.     l = l + li * m_y[i];1 a) v4 T3 {$ n3 X4 z3 z0 _
    
98.   }
    + Q& l6 i' @7 j. }\" N* }8 C# G' m5 v
99. #else
    / z+ _! o+ P8 E# t. a+ T, x2 Y
100.   if (!m_lagrange_interpolating_set_n_arr()) ' K- J6 r4 {# {% x
     
101.   {
     4 `+ @7 R1 t7 j$ _! Z7 y
102.     printf("Error: xi and yi counter is diff\n");( q! ~# P2 K7 [  x6 ^( h9 A
     
103.     : y6 ^% C- q* P* D' e\" R$ |! a0 p
     
104.     return 0;1 F2 e+ C! C( S- M  i9 L
     
105.   }
     / U; ]- u3 Z3 ~9 k. l
106. 
     4 d5 z: o* n( e- k7 a* n9 M
107.   for (i = 0; i < m_n; i++)
     3 r0 O6 h3 ^0 }4 ~- X+ }6 w; y( Y
108.   {
     1 O0 g6 d0 s; l3 z9 a6 e
109.     li = 1.0000000;7 G! y9 D1 ^; |- J/ N7 G$ x1 `* C
     
110.     for (j = 0; j < m_n; j++) . r! j& C7 s, d) D2 ~6 B* d# o. I
     
111.     {& z' @( n' J\" d2 w
     
112.       if (j != i)
     \" R: P7 J8 u5 K7 G. d9 t; Y4 t
113.       {& i# s\" n: l8 X! C( ^
     
114.         li = li * (m_p - m_arr[j + 1]) / (m_arr[i + 1] - m_arr[j + 1]);
     ! M8 k+ P3 P! {# s
115.       }. m; o# a- o; ^3 i
     
116.     }
     2 ?  z& x# P# }  _: m* Z' t+ L; ?
117.     l = l + li * m_arr[i + m_n + 1];
     \" k# ?$ r- I\" w
118.   }
     & i: c( u, Z8 A$ y
119. #endif
     1 J, F. ?/ c- M\" A, o  Y& i
120. * m8 s# p% L8 _
     
121.   return l;
     3 D2 o: |  m8 J% t
122. }. M) D# C* p) x
     
123. 7 ~2 \* n1 U' V' f: W4 i
     
124. int & x5 R8 d) k+ [) m# z/ U8 ~
     
125. main(int argc, char **argv) ; L; O% x+ [' p9 ?; T
     
126. {
     - |' q8 u7 T9 x+ p( C3 W( |
127.   int c;
     # u/ C8 e1 Q5 O* n5 v
128.   extern char *optarg;
     : `\" l' J3 j' v5 z& B5 W& S
129.   float res;6 |9 |( G7 {* i0 D# E
     
130. : ?8 g# B& w5 X3 m7 q' A$ Z
     
131.   if (argc < 2) . O& S1 X4 a  G! I; m9 ]
     
132.   {7 C- G. {: }1 I6 w2 u
     
133.     m_lagrange_interpolating_usage();
     & b8 i/ G3 S3 x
134.    
     9 A; p9 V) w0 U
135.     return -1;
     # X! V+ T/ d& M, q2 ^0 P( i
136.   }2 R1 J4 i. t+ e0 V% F- U\" d5 h
     
137. 
     1 m: U. I3 }8 D6 q. c. g- x: |
138.   while ((c = getopt(argc, argv, "p:x:y:")) != -1)
     ' G; h, a  S! ^# F\" z, P
139.   {
     ! C( F9 ?6 C2 F5 p4 a7 z5 q( R
140.     switch (c)
     8 r+ a9 I4 K/ w0 Q
141.     {
     ; E+ g( K* ], A) Q9 C& B
142.       case 'p':- @6 @. J$ `) z7 w
     
143.               m_p = (float) atof(optarg);
     8 b$ G$ ~# @0 |7 N
144.       case 'x':. J) d1 h( g6 y6 b' ^1 o
     
145.         m_xi = optarg;
     : B# [7 s2 f+ C1 h3 O
146.         break;
     & M1 ]4 L3 w+ \; m
147.       case 'y':9 h8 \6 P* {7 U/ n
     
148.         m_yi = optarg;
     - ~) Y5 [6 N8 @! _5 J
149.         break;% g  x1 t7 U) }2 U
     
150.     }  O( b5 ?, B2 Q0 L
     
151.   }
     ( B4 a) E: n4 y) z- y2 w$ B- t
152. 
     & o6 M9 J4 b* P
153.   res = m_lagrange_interpolating();
     \" a; `7 ?. k% @\" }( c& C& ^8 a
154.   printf("Lagrange interpolating with %.4f result is %.7f\n", m_p, res);, p$ N6 l' H% p
     
155.   
     ! ], G; ^( R! a9 W
156.   return 0;& G  @2 H3 b3 S  s. d/ u( V
     
157. }1 |' v9 Q/ U4 R
     

复制代码

lll111

我要下载。我要下载。我要下载。我要下载。我要下载。我要下载。

xhz-hhu

谢谢谢谢，找了好久呢，谢谢楼主的分享

depht858

谢谢，正需要

hastykeys

谢谢，正需要呢！

芸芸芸

谢谢，很想看看，没钱啊

mao233

谢谢分享，有了这个插值就方便多了