[分享]插值软件langrang

ilikenba

软件名称：EXCEL自定义插值函数插值计算数值计算 p, F$ \7 @ h1 O; Y: t$ j版本号： 04y09m28 分类： 工程设计应用 性质： 免费软件 7 q# N- k9 i" a( D4 U, A: w2 k2 j使用说明：

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

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

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

注解： : l$ \' R Q. q4 b3 N$ j Description:用户自定义描述字符串（Description中不可有@符号）； n: 总插值点个数； nsel：实际参与插值计算的插值点个数； MinX=0.7,MaxX=0.9 取值范围； : O( ]1 ^. ^0 c1 C; A* Y9 V OverRangeAlm=1 越限报警 1:报， 0：不报; X=电压,XUnit=mv,变量名称，单位。

. ?3 z) f: T7 i2 X. H

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

F: ^& H; M J. _- M

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

( n+ g! ^9 J- J% ~. @) i$ w; z

ww991616

ft12345

好东西，谢谢斑竹

xiangzhai83

1. 9 @) J& w( ]/ ^' ~4 N% ~! ]7 p0 j
   
2. /* TODO: Lagrange interpolating * {$ B1 `) y( r) B
   
3. *5 _$ W9 @2 `3 x
   
4. * For example, if lg2.71 = 0.4330, lg2.72 = 0.4346, then lg2.718 = ?1 W+ v6 ~4 ?8 D) c) q6 L: L  g
   
5. * In this situation, it could be solved via lagrange interpolating
   * L8 L9 Q4 w/ X  w\" Z: f
6. *
   ! c2 ]7 T$ N0 K* w# d. V) U! G
7. * */
   / D  c\" R# V( b: K7 s6 W3 u\" Z
8. 
   ! f) I$ a3 L/ h5 J  Z7 Z
9. #include <stdio.h>
   6 f$ p+ P$ D  L2 d! K
10. #include <stdlib.h>
    5 ?2 H5 ^$ Q( a: s
11. #include <string.h>- i3 u, ]4 R3 a  g$ i8 c/ f
    
12. 
    # Q5 i  @% I3 x\" t- W
13. #define DEBUG 0
    * `* ]: z( V+ d2 {
14. . X; Q3 M; D, y, @8 T. {0 R
    
15. static float m_p = 0.5635;$ T+ Z5 N1 K0 A6 ^0 z
    
16. static char *m_xi = NULL;0 \) d/ j% \4 `4 D
    
17. static char *m_yi = NULL;5 V( h+ Y( O; W
    
18. static float m_arr[] = {};2 E1 s! y* O% b/ _9 ]$ l# [
    
19. static unsigned int m_n = 0;# ?& L5 N9 _4 N2 w$ m
    
20. : J) K& e, W+ R+ i0 A3 ~: G/ F
    
21. static void m_lagrange_interpolating_usage();
    ( G. |# t) I/ ~- f3 s/ w
22. static int m_lagrange_interpolating_set_n_arr();
    6 C& e7 C5 p& @* u/ S
23. static float m_lagrange_interpolating();
    ) _% }\" f9 V\" {$ b\" z! y
24. $ W3 r: V1 Q$ F3 T- m7 n. `
    
25. static void
    7 P8 Q0 C& b- V
26. m_lagrange_interpolating_usage()
    0 r+ k0 y2 w) P
27. {
    + n) D; H( ?' ~$ L4 s- p; x4 w
28.   printf("Lagrange Interpolating Usage:\n");( f* d2 }( |! `2 |2 \, W
    
29.   printf("bin/li -p ** -x ** -y **\n");5 l: G- Z2 j\" c3 o  ?
    
30.   printf("-p 0.5635\n");
    1 Q5 K- N. d; F\" X2 S( p
31.   printf("-x 0.56160,0.56280,0.56401,0.56521\n");1 Q# k& O; H* q  {  t6 S( E
    
32.   printf("-y 0.82741,0.82659,0.82577,0.82495\n");) {' {8 ]! @( |# {( @/ T
    
33. }% y0 V7 |4 k) ~\" G9 }
    
34. ) ~& u0 o( N1 \5 P! W# F\" \
    
35. static int   t0 X! P4 M8 |0 ~
    
36. m_lagrange_interpolating_set_n_arr()
    9 z\" d* C2 T3 w
37. {
    1 f9 B) p7 N4 N9 ?8 l
38.   int xi_n = 0;
    1 O: j- ~( @( x/ ^7 Y
39.   int yi_n = 0;\" g, G: f. _6 ~$ _! @( s5 F6 i+ C
    
40.   int n = 0;* o( t1 e$ n5 L4 G+ Q2 n
    
41.   char *token = NULL;# r/ B' q7 Y! {2 o  e$ N7 V! i
    
42.   const char *delim = ",";
    \" |# A( A: |# w: }) K; s, H4 T' j
43. \" {: j5 N5 K) }3 U. T6 C, H
    
44.   token = strtok(m_xi, delim);
    / `1 y\" F. X/ Y7 s\" A% r: i
45.   while (token); U; r  U0 D3 c; ?( e
    
46.   {
    4 ]: ~1 g1 ?% ?; q# W& A4 D4 X
47.     xi_n++;# g0 O; [. R$ E1 @0 a- o, N
    
48.     n++;
      Y# n. {+ t/ i. B) p8 ~
49.     m_arr[n] = (float) atof(token);
    9 {' T+ }# b\" N& L) E0 w) u
50.     token = strtok(NULL, delim);
    : c6 {9 b: E' t' ^) `
51.   }, g0 Z2 r, e- P. }7 R
    
52. , I$ a4 O3 |4 L6 k% x8 V) E* z8 k
    
53.   token = strtok(m_yi, delim);! w- F\" _0 v5 `0 l* y. r7 e0 R& `
    
54.   while (token)
    & U; @1 q4 L5 j- V, R. j
55.   {
    * @( E# l8 d5 m3 l/ U8 s  r
56.     yi_n++;; u7 `. W\" ~: ?
    
57.     n++;, ]6 H: E$ w0 d
    
58.     m_arr[n] = (float) atof(token);
    - Q1 G* x( g, v0 W3 t3 G/ ~  F3 X
59.     token = strtok(NULL, delim);
    1 W  ~; x* ]5 _. J9 c7 R* N  F
60.   }7 N9 ?: k% I  g4 Q- ?; L7 ]3 }) E( J
    
61.   1 y  G\" Q0 R# w- d) W) k: H7 B
    
62.   if (xi_n != yi_n)
    1 M' ]/ U3 Q) _$ n' K) v2 t
63.   {
    ( s8 A1 S' y; W: O
64.     return 0;\" d* \0 x2 g/ A; K
    
65.   }  ]8 k% b2 a/ P: e, J9 y. x
    
66. 
    \" k9 _% E3 T5 t) k& N
67.   m_n = xi_n = yi_n;2 @: z6 v& S1 O* k
    
68. 6 {, \+ V, Y  @
    
69.   return 1;! m: ?$ ^3 [& [7 X  o& V) }. g
    
70. }
    , r7 G7 Z/ A5 X9 W% }
71. 
    ) V! E. y* P* a
72. static float & j: Y5 d, }6 s
    
73. m_lagrange_interpolating() ) ?8 J\" z4 n& T5 J
    
74. {
    & u& E! N# e1 f! i' H$ Z3 E
75.   float l = 0.00000;
    5 q- I/ p* v2 O
76.   float li;- e- Y\" I\" y! [
    
77.   int i;
    ' y- e- U$ s. _3 _. ?2 k5 \
78.   int j;
    2 X\" f5 F$ B7 G0 a6 b
79. 
    : n6 v: u& a) S% x
80. #if DEBUG
    # O6 C  Y3 x0 C3 w
81.   printf("DEBUG at %d: enable debug mode\n", __LINE__);7 {9 S& x( \0 M3 H. p& U$ U
    
82.   unsigned int m_n = 3;
    9 j4 k3 y% q# S3 l
83.   float m_p = 0.5635;
    3 i5 V* e+ D5 S3 E- x
84.   float m_x[] = {0.56160, 0.56280, 0.56401, 0.56521};1 Q/ q. M- ~6 H7 y* e
    
85.   float m_y[] = {0.82741, 0.82659, 0.82577, 0.82495};+ R7 ^0 e- W# C) i7 v2 }
    
86.   3 M8 I0 q\" U1 x7 m\" i: n: ^* K; E
    
87.   for (i = 0; i < m_n; i++)
    / L# Y% _+ U& O
88.   {
    % T& n4 K\" p# y6 Y\" U* H& b+ a3 L% ~
89.     li = 1.0000000;
    / X0 P! L8 }+ W4 u: Y9 H
90.     for (j = 0; j < m_n; j++)
    5 X% q! F2 _/ \; \6 _3 g7 e' u+ k
91.     {\" Y0 ^: m) N: R
    
92.       if (j != i)
    6 Y* T7 ^) E% [1 W; ~: t/ k5 o
93.       {
    / ^( h: q0 _! P9 M+ T
94.         li = li * (m_p - m_x[j]) / (m_x[i] - m_x[j]);
    / z2 [5 i: m9 {$ B, z+ Q0 |
95.       }4 p5 A; r, j+ o) Q4 i
    
96.     }. ?3 Q/ \& |8 e6 d
    
97.     l = l + li * m_y[i];& [2 ~1 u2 b1 N, q' c
    
98.   }+ k6 J% f7 t. _4 o4 ]
    
99. #else
    : |: M& i$ O' Q' P# H4 V7 \
100.   if (!m_lagrange_interpolating_set_n_arr()) 0 U: k8 J) R( t+ b\" T
     
101.   {
     : g7 Y4 @4 J+ w6 Y
102.     printf("Error: xi and yi counter is diff\n");) V1 X\" f* ~$ \
     
103.     ' v: C; O1 D9 J, v& Y
     
104.     return 0;
     + V0 Z/ t( W/ i& M
105.   }
     * [2 @8 A, G: H0 ~/ x0 O; `$ }' A
106. 6 a\" [# a- m\" D; c# s
     
107.   for (i = 0; i < m_n; i++) ! ?. k$ h7 w2 u+ V2 v
     
108.   {
     9 c- b4 N# I# Z& K! s
109.     li = 1.0000000;
       |( P+ c( s. H5 J5 N# F
110.     for (j = 0; j < m_n; j++) + {6 D( j2 `# [, |
     
111.     {/ X$ L6 g+ s* z2 i
     
112.       if (j != i) \" q4 ]5 b1 P5 k5 s' W6 b$ [( k
     
113.       {0 k! V5 ~' S7 ]1 X, K
     
114.         li = li * (m_p - m_arr[j + 1]) / (m_arr[i + 1] - m_arr[j + 1]);, w& h! `/ h$ }, T4 U
     
115.       }7 ~4 K0 ~% t0 Y6 g5 e: h
     
116.     }$ ]; z0 Q3 p) s
     
117.     l = l + li * m_arr[i + m_n + 1];
       K6 F0 m. P1 G- R
118.   }
     + e- L6 a\" ?6 L; v5 M5 w\" n
119. #endif
     8 E, y8 z- p& e4 w: t
120.   O2 i* J- ]0 h4 [4 s
     
121.   return l;
     : t% r9 |. ^/ x9 V: `* G) ~0 r\" V
122. }
     1 r; R7 c/ K6 y# i
123. ; Y/ \7 C, J7 U! R* q' U! ~' w% e
     
124. int 9 A+ x! _, o# `# M, n
     
125. main(int argc, char **argv)
     5 g  N, U$ P. d2 `3 ?
126. {5 B+ g4 ?/ b% X- Z# `6 H
     
127.   int c;# A: m. m7 p- b  Y# U
     
128.   extern char *optarg;: e( X% b! x' O$ z
     
129.   float res;
     \" l: ?$ w6 k! ~. c! Y
130. 
     % X$ S\" N  X2 \' e  C2 [+ \6 e2 F
131.   if (argc < 2)
     4 A* e2 ]( {% ^! m/ g) ]9 @4 y# _
132.   {
     ! b! f& e$ y$ {- V6 ]! j2 k# D! U
133.     m_lagrange_interpolating_usage();- {& G, R* ^1 c, d# R  G% p
     
134.    
     / o; ~- Y, R# V, f; Y+ _
135.     return -1;
     \" A& t5 k. ~  A% R# e6 l
136.   }
     . {. f0 |* Z: S6 H* Z4 Q
137. 
       `2 ?+ M$ V( T1 r( }
138.   while ((c = getopt(argc, argv, "p:x:y:")) != -1)
     ; \$ d8 M1 J% o7 d( y& L
139.   {* E6 G! W. J* |2 I\" a+ W
     
140.     switch (c) 7 h: v5 A; B  z% h
     
141.     {6 r) E' [0 U, ^4 o7 i) h
     
142.       case 'p':, {* J) O! ~1 [6 b# K; h- R
     
143.               m_p = (float) atof(optarg);
     # j3 \/ A8 ]6 J& ~1 b
144.       case 'x':
     5 b4 x1 {+ w9 ~; R$ J% D
145.         m_xi = optarg;
     8 T, Z\" P8 U% P0 T
146.         break;
     + p# d\" B2 W, Z& b* ]
147.       case 'y':  ]9 w2 T# \; O  D# r1 j
     
148.         m_yi = optarg;& V4 R1 k6 ?. _' y+ ~
     
149.         break;/ l- R, J\" w  I/ T9 H' S+ {; G
     
150.     }
     # d- U# m6 P4 j) Z6 l. s
151.   }
     9 A0 p4 [. O, Q$ a, V, u! N, a
152. 
       m  x8 _9 i& l* O
153.   res = m_lagrange_interpolating();6 |+ c  \  V+ M7 }5 j- c: G
     
154.   printf("Lagrange interpolating with %.4f result is %.7f\n", m_p, res);
     & Q  D5 l+ V1 Z/ W
155.   
     % Y8 f, p, s+ ^! l& t7 v4 u6 {$ i
156.   return 0;0 O5 v; U  v2 d. v
     
157. }
     1 m4 K% l! K0 u# ]3 }8 Q5 {8 h

复制代码

lll111

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

xhz-hhu

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

depht858

谢谢，正需要

hastykeys

谢谢，正需要呢！

芸芸芸

谢谢，很想看看，没钱啊

mao233

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