[分享]插值软件langrang

ilikenba

软件名称：EXCEL自定义插值函数插值计算数值计算 版本号： 04y09m28 6 f5 @8 l$ W3 L8 H# V/ l分类： 工程设计应用 性质： 免费软件 使用说明：

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

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

% m7 [- Z* b! {: R1 `; X8 R: K

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

/ O% `, |6 t5 o) E/ o; e9 Z. y1 C" n

例：单曲线插值函数 "带路径的保存数据的文件"结构如下： , K4 o* ~$ [ h- z@ 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

( B7 g4 B- n3 q/ K# {

注解： Description:用户自定义描述字符串（Description中不可有@符号）； n: 总插值点个数； nsel：实际参与插值计算的插值点个数； ! W6 B' H1 f9 _6 H, p n$ b. T MinX=0.7,MaxX=0.9 取值范围； 6 l% F2 @4 A! B$ {' k OverRangeAlm=1 越限报警 1:报， 0：不报; X=电压,XUnit=mv,变量名称，单位。

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

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

ww991616

ft12345

好东西，谢谢斑竹

xiangzhai83

1. 
   7 l* m) v1 g) v# f/ ~& x5 }
2. /* TODO: Lagrange interpolating
   $ \: n& h: a  Q1 y3 b\" {# d  h
3. *
   8 A% A3 A* f6 q/ Z\" ?) \2 ?2 h3 B
4. * For example, if lg2.71 = 0.4330, lg2.72 = 0.4346, then lg2.718 = ?
   8 V$ o* L% q$ q6 u2 s. B
5. * In this situation, it could be solved via lagrange interpolating
   * s+ n5 }' s+ v# [# g
6. *0 i* Z( c5 P& u( S
   
7. * */
   4 O5 h9 r7 @4 u+ U# o- d
8. \" j- g: H! a0 L7 `. l3 q
   
9. #include <stdio.h>
   $ ~\" ~: x6 \7 G( b  l
10. #include <stdlib.h>3 `1 S+ n# ~+ Y, l' r
    
11. #include <string.h>- Y$ G* l' B- h# z
    
12. + ~+ b/ ]9 o! l9 [
    
13. #define DEBUG 0
    ) h7 J! G3 c& p; g( x5 S8 U( @, P
14. ( D; m\" a  c2 o
    
15. static float m_p = 0.5635;
    ' a4 [$ s' A4 ~! A( B
16. static char *m_xi = NULL;
      m0 s3 F. O- f; k- ^
17. static char *m_yi = NULL;
    % e) S, c. X& i+ M% V
18. static float m_arr[] = {};  X. \$ n3 R$ l  D  x
    
19. static unsigned int m_n = 0;  d, L$ _\" F: {) s' |; U
    
20. 
      `3 `5 D6 l  e; z
21. static void m_lagrange_interpolating_usage();
    - A! @5 ^$ c4 K$ _- d
22. static int m_lagrange_interpolating_set_n_arr();( z* A$ s, z0 }, O1 F
    
23. static float m_lagrange_interpolating();1 d/ ^6 B4 Y0 t/ V' U9 X2 ~
    
24. / r) d( {) m3 |  k6 W; C: T
    
25. static void
    5 F+ D2 R. o+ G8 O6 j\" l
26. m_lagrange_interpolating_usage() 2 L# q& U\" R% W9 T6 I  O
    
27. {
    3 \5 ~, ~* `6 g- c( f/ w8 U
28.   printf("Lagrange Interpolating Usage:\n");
    ; x9 O2 Q4 K& ?: Z; G, h
29.   printf("bin/li -p ** -x ** -y **\n");( o' w6 q5 n3 W: i# Y
    
30.   printf("-p 0.5635\n");
    4 ?) [* I( ?( Q0 C  ^5 m  O
31.   printf("-x 0.56160,0.56280,0.56401,0.56521\n");. c# D4 e: @1 M( b; j& K
    
32.   printf("-y 0.82741,0.82659,0.82577,0.82495\n");4 V9 B. ]6 P8 d/ A! |4 J5 J
    
33. }* ^) v& }. a5 r\" f, Y
    
34. * p( l( p, R7 c
    
35. static int 6 ~3 a5 z; c  V, d0 v
    
36. m_lagrange_interpolating_set_n_arr()
    5 B& ?7 P# c\" S1 z\" f* ^$ u
37. {
    : C7 O& e4 P  c
38.   int xi_n = 0;
    ( z& W. S5 i6 P0 f% h; h
39.   int yi_n = 0;! ?: A. w$ P, i. |' m2 o
    
40.   int n = 0;# H# Y  N! S( l6 e- e
    
41.   char *token = NULL;
    ' z, S# C0 I5 w3 Y
42.   const char *delim = ",";
    ( y8 Y( Z8 }( r; H
43. 6 e  u1 @  [( w0 V
    
44.   token = strtok(m_xi, delim);
    / f) N7 ]$ m- a% @
45.   while (token)9 V/ p$ u\" [$ c( ]
    
46.   {' z# D/ e' B& y3 q
    
47.     xi_n++;' i8 ~' K) L5 z/ H
    
48.     n++;; N* Y( j: A9 }2 }) D
    
49.     m_arr[n] = (float) atof(token);
    ; N+ n* R. w( p# C/ F
50.     token = strtok(NULL, delim);; I) c$ \& K  J& Z! i4 n( s
    
51.   }
    4 e% h. d1 `6 |
52. ( b& \4 z# m$ g\" t2 J7 x( x; a
    
53.   token = strtok(m_yi, delim);4 N7 Y8 n& f9 c, a  `5 q% u8 w: m+ ?; c
    
54.   while (token)
    6 x! y& [3 p1 y1 m0 G
55.   {! w- ?+ M& m& s' z! e  _
    
56.     yi_n++;
    ) F/ g/ Z1 i( d5 }3 P- E
57.     n++;
    2 a6 X5 o) G9 ^# w. i- W6 L) ]
58.     m_arr[n] = (float) atof(token);% K; r1 i3 w1 N$ p
    
59.     token = strtok(NULL, delim);
    - M- m$ l6 j. z3 ]: ^
60.   }& Z5 Z, x2 N' u3 r; E6 r7 u
    
61.     v+ E; Y& I\" _- k8 @, B7 G
    
62.   if (xi_n != yi_n) 1 T) |+ I/ j9 e3 d5 @; U% {9 G- N0 F
    
63.   {
    7 h: V6 \! O9 M$ t# ]) Z
64.     return 0;+ K. w\" R) Q, M\" r$ G
    
65.   }5 H- ~3 n) B4 f$ D4 _) _
    
66. 
    3 v1 i( o* ?2 O- \- z
67.   m_n = xi_n = yi_n;
    8 d+ f7 G) K! m& u
68. 
    1 E9 Z0 A, \0 v! F0 [; {' B
69.   return 1;
    # O8 O# H6 v; ]# a% d
70. }
    6 M& K# d: T! x
71. 2 N4 ?6 W7 J4 q+ B% T# ]! V5 l
    
72. static float # H, J; ~9 m/ Z: y) c2 Q0 T2 X0 i
    
73. m_lagrange_interpolating()
    5 [5 b4 P& H9 m: l* j
74. {
    # w# K, k& y$ p1 z7 ?( R# r
75.   float l = 0.00000;# r( e3 M. O2 Z# o) O: q
    
76.   float li;\" f7 n% p  p+ U( s! W
    
77.   int i;
    9 Y\" K- @% r* e/ J
78.   int j;
    1 @4 ~' x3 T3 A8 r; x
79. . p# K5 q: e1 j8 V
    
80. #if DEBUG
    7 X! W\" |$ `1 ~7 ?5 _
81.   printf("DEBUG at %d: enable debug mode\n", __LINE__);2 Z1 ]2 X- u( S( _9 L5 t: D
    
82.   unsigned int m_n = 3;- C% s' r3 k/ p$ ]: Z* c
    
83.   float m_p = 0.5635;4 ^; k* Z* m! ^4 i! u' o
    
84.   float m_x[] = {0.56160, 0.56280, 0.56401, 0.56521};) H+ @$ Q3 V7 W6 o4 G3 Y$ j
    
85.   float m_y[] = {0.82741, 0.82659, 0.82577, 0.82495};$ V9 H8 R) T1 f
    
86.   
    : k* [\" ]8 {+ @
87.   for (i = 0; i < m_n; i++)) T4 n5 H+ ^0 k8 u4 l9 m\" L
    
88.   {
    \" t0 M0 H, X- O  o8 @! ]! \
89.     li = 1.0000000;- \- K3 B3 V7 N: q3 v* @* U
    
90.     for (j = 0; j < m_n; j++)
    . v7 W8 W+ ~# n5 K- }
91.     {
    . N& y  G- g! |5 E. _$ U% @
92.       if (j != i)
    ' R, O% [1 X2 Q' F' Y8 o
93.       {
    ! w1 k( l$ z* V5 X+ E1 F+ ^
94.         li = li * (m_p - m_x[j]) / (m_x[i] - m_x[j]);' l5 f8 H9 ^% L, \1 z+ z6 P5 o& x
    
95.       }, M. N. @1 A2 M  @! g
    
96.     }/ v7 C( h4 r% G9 z/ E' ?3 t
    
97.     l = l + li * m_y[i];
    ) U& z9 B+ D3 O; Y
98.   }
    1 N6 @5 D# V; L7 \/ w6 ]
99. #else5 i) W2 j% e% i2 P) T* @5 u
    
100.   if (!m_lagrange_interpolating_set_n_arr())
     & `. G6 b7 h- ^# f\" }; G8 |
101.   {$ p9 `( v& v3 e' g
     
102.     printf("Error: xi and yi counter is diff\n");' }( v! L: f6 j# b, g9 d
     
103.    
     . @) ]; H\" U. o2 H
104.     return 0;
     8 j/ s' B- M* v( C- l& m
105.   }
     5 t# P# M7 l% i. U
106. 
     - \& Y9 u  B) }2 C9 w6 Z
107.   for (i = 0; i < m_n; i++)
     \" y$ D* Z0 z5 Z+ p  P& [
108.   {) X# C% j) ^; [5 P  F
     
109.     li = 1.0000000;
     4 Y' p. i. t' C1 k7 V
110.     for (j = 0; j < m_n; j++)
     , H+ ]1 z: H  [5 a: N7 ?
111.     {
     1 T2 s5 M0 z# U! i
112.       if (j != i)
     , J! H( j- @: x6 B8 R& L
113.       {
     * ?& M2 x3 H* ?4 a: |% x1 b4 F
114.         li = li * (m_p - m_arr[j + 1]) / (m_arr[i + 1] - m_arr[j + 1]);5 `3 `+ A7 e% C3 w# q
     
115.       }( O# }% Z+ e7 P
     
116.     }
     + Y, D4 m5 z7 x) K7 u
117.     l = l + li * m_arr[i + m_n + 1];
     6 c; J; T, |# g: X( ~
118.   }
     - M& m5 U' w6 z1 i
119. #endif, V4 W! ~! Y4 T+ D
     
120. 
     3 n$ k$ R2 _, m& g- m' R: G  L. F
121.   return l;
     1 J) J6 X  @7 {! \1 q2 d
122. }4 V5 [3 T: `( h
     
123. $ R; |, b8 c) |5 @6 p5 T( S
     
124. int $ Y+ Y8 X8 U8 z
     
125. main(int argc, char **argv) 4 L2 \\" F4 r- E' p8 @3 P9 w8 B8 A
     
126. {
     3 O0 _$ m( H7 R7 }- g0 p\" l7 M5 p
127.   int c;
     * {3 g* o! L, Y! ?' R7 J
128.   extern char *optarg;* `+ f/ \\" y5 ]3 Z# _) m
     
129.   float res;
     ) {8 ~5 c3 e: G8 I6 a
130. 
     : E9 z+ ]( s0 ]$ M5 G6 \
131.   if (argc < 2) \" S; n6 s0 d6 V: I: H$ b
     
132.   {5 A1 Y8 o! f: u& l) J
     
133.     m_lagrange_interpolating_usage();
     4 O  ?( a1 W$ W6 I\" f7 W
134.     # F0 P- J2 U\" L  O9 X6 z# G
     
135.     return -1;0 Z5 Q* k& n( ~  K5 y: g6 s
     
136.   }
     , F\" C  N, H4 P, T3 _
137. 
     9 K9 q5 q+ S& t  z& ^0 R2 v0 C
138.   while ((c = getopt(argc, argv, "p:x:y:")) != -1)
     2 n: }( _$ a3 t6 l2 |% a& J
139.   {) o1 j2 W' z9 ?
     
140.     switch (c) ( U% j\" L8 p6 S5 D$ X5 K  l
     
141.     {6 L2 j4 r\" S6 v; C# f0 Q( ]+ P
     
142.       case 'p':
     4 u: N$ y% Y. B7 U( y- w: I9 d* ]
143.               m_p = (float) atof(optarg);
     , o: ?- M7 C4 c5 H\" ~1 u
144.       case 'x':
     ' |7 \. j+ w  J$ K4 @
145.         m_xi = optarg;; i* {7 \7 u5 y. T
     
146.         break;3 L8 e$ y) ~6 G
     
147.       case 'y':. [. S: Y. e: h3 H
     
148.         m_yi = optarg;4 g( ?3 p& `7 L$ ?4 T9 X
     
149.         break;
     6 u9 o! h) w5 K/ C
150.     }7 E, B) A8 v* v+ i, G3 c) J
     
151.   }
     2 X' K# b2 i\" v! t3 r
152. 
     - f  a5 f+ D; A8 k0 ]5 {
153.   res = m_lagrange_interpolating();
     + y2 q# E6 L' h* f% V
154.   printf("Lagrange interpolating with %.4f result is %.7f\n", m_p, res);
     8 B. m( F( R: P' ^1 a* Y3 w$ C
155.     ?( g9 v; n& L- y$ ?, q
     
156.   return 0;
     8 h/ W) S' a4 V2 d1 ~
157. }' M$ `; j3 t# R1 I
     

复制代码

lll111

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

xhz-hhu

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

depht858

谢谢，正需要

hastykeys

谢谢，正需要呢！

芸芸芸

谢谢，很想看看，没钱啊

mao233

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