Lu中的运算符重载

forcal

    在Lu中可以很方便地对运算符进行重载。例如：

1. thetype(x,y,num,op)=which\" Z3 _\" f\" ~( _$ U! S
   
2. {% G9 h4 x6 X' [# Z7 Q. r
   
3.   op<0  : return[newtype()],) i) ~/ n5 ?+ w8 `, d$ _. e0 }0 R
   
4.   op==0 : x-y,    //重载运算符+1 W4 v3 T8 g& V- _- f/ H/ R
   
5.   op==1 : x+y,    //重载运算符-
   & u+ p2 M/ h7 Z
6.   op==2 : x/y,    //重载运算符*9 Y% b( X3 s' ?6 ~& q
   
7.   nil             //该数据类型不支持该运算符的重载，返回nil
   + Q7 c- a. N/ \; u
8. };5 H  m% b8 m/ @
   
9. test(:type,a,b)=
   * ?  x: `- S) x( D. i
10.   type=thetype(0,0,0,-1),  //获取新数据类型$ G\" D' x2 u4 q% i' q9 L
    
11.   a=cast[3,type], b=cast[5,type],  //强制转换为新数据类型
    1 V2 m' G  A: I8 m! d3 Y# Y
12.   o[" a=",3," b=",5],  //输出a和b
    / g+ s/ h7 J6 X  a  Z4 [
13.   o[" a+b=",a+b],      //计算并输出a+b，变成了a-b
    . s/ _2 i; I) c* y! G6 H
14.   o[" a-b=",a-b],      //计算并输出a-b，变成了a+b
    1 f% p& Q) f) s5 G% x
15.   o[" a$b=",a$b];      //没有重载运算符$，故输出nil

复制代码

结果：

1. a=3 b=5 a+b=-2 a-b=8 a$b=nil

复制代码

＝＝＝＝＝＝
3 ~5 z/ l" i$ U- x1 Q
  Lu核心库中没有提供矩阵运算，但在脚本中可以通过重载运算符来实现：

1. outm(x:i,j,m,n)= //输出一个矩阵
   2 w! j' |, L* e2 |9 F\" o+ A
2. {$ @5 x* a; f7 g! w' U
   
3.         len[x,0,&m,&n],# H; e/ ^) y) m\" m/ E' ^) [6 e
   
4.         i=0, while{i<m,
   ; Q# z  X+ w. S% E. H% ~( Z
5.                 o["\r\n"], j=0, while{j<n, o[x(i,j),"  "], j++},
   & \$ e  @  {1 H( Q2 j: \& ~! C. H% _
6.                 i++6 j& x6 W# @1 }: l$ x
   
7.         },
   5 i, B. k$ S# U5 N+ P6 p
8.         o["\r\n"], x
   7 G4 W! S9 M' g0 }/ u3 l( A' A
9. };' n9 B! ^8 a- {4 O$ x
   
10. mymatrix(x,y,num,op:c,i,j,k,m,n,u)=which //定义矩阵运算
    - x5 \* O: V\" ]0 a& W1 e# \! [\" O
11. {+ K1 x3 Z7 W- ?0 C
    
12.         op<0  : return[newtype()],8 j% S) _/ Z+ I3 }3 H# N0 S
    
13.         op==0 :        //重载运算符+. \3 |# H  O# c
    
14.         {) N6 A. S. J6 S. b( e  z
    
15.                 len[x,0,&m,&n], c=new[reals,m,n].global(),3 v6 p0 D3 @0 O% w: t5 j) S
    
16.                 i=0, while{i<m,
    + U. E8 Y% U& Y6 l3 T
17.                         j=0, while{j<n,* p6 X0 ^8 A# a\" l
    
18.                                 c[i,j]=x[i,j]+y[i,j],: F5 b; @' h* K* |+ F$ ~% M; V3 q
    
19.                                 j++; l) B2 g' s0 t\" D' M; k
    
20.                         },4 E2 s  Y0 U: q; @2 v4 r3 c! T
    
21.                         i++
    , D4 Y3 u! p& _( c
22.                 },
    1 _8 [5 `/ A$ T% p
23.                 c- S! G$ x& w( m8 Y
    
24.         },
      D# \4 V& q% i; L) X
25.         op==1 :        //重载运算符-
    + V1 E& h* D3 f2 O! Q5 M/ o; o
26.         {! `, C4 G, |/ d1 x0 o& Y3 V! L/ D) R; J
    
27.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    8 t, J- K5 H% O& e
28.                 i=0, while{i<m,( e: {! X9 a5 F4 O$ R4 q' l
    
29.                         j=0, while{j<n,
    ) R% X) J2 z% y, K3 S& r* Z+ p
30.                                 c[i,j]=x[i,j]-y[i,j],
    ! q' V$ }- G1 v. q* B6 p4 L
31.                                 j++3 w, }: o* N0 _# i
    
32.                         },
    ; c' m6 f9 f\" X; D: _9 Y) v
33.                         i++# B* ?! D9 j3 a+ j; s  K) G
    
34.                 },* W2 r! x3 V2 {& i2 ~9 A6 E
    
35.                 c; W5 }6 T\" Z% J5 _
    
36.         },
    - [5 g% [/ l, w* ]! p$ n: e
37.         op==2 :        //重载运算符*5 Z( Q3 F/ `0 j0 c' w& v
    
38.         {
    1 a/ T! I5 b5 T  p/ G  S
39.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),
    ! w8 }6 x' H) ^  N& b3 _9 t# B0 P
40.                 i=0, while{i<m,
    # f! `  _1 v6 M  U
41.                         j=0, while{j<k,
    $ F# C# ?, z! o; R, L
42.                                 c[i,j]=0.0,( G+ Y( E6 e2 x; Z- ]1 y- G' ]3 D
    
43.                                 u=0, while{u<n,  \, U4 B4 W3 E
    
44.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++7 }6 A$ Z# r: L4 b* ~. S# @. t
    
45.                                 },
    / S5 o3 k$ x3 w: Q$ i5 O' O9 T; I) ~
46.                                 j++
    5 d. U: J# z( I2 N4 G' C  t
47.                         },) a5 g2 _3 K1 {0 O) \' f
    
48.                         i++
    6 [' Y9 X\" y  b4 Q
49.                 },
      e. `$ ?, h  O
50.                 c) j* G: Z' P* j
    
51.         },
    * p9 N4 w% S# r  Z% v+ M
52.         op==25 ://重载运算符.*2 h0 E- H\" \9 D/ Q+ I. E% E3 X
    
53.         {; u# p# P8 {' H+ J
    
54.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
      V7 t, j! U3 B- _7 d7 Y- H1 R
55.                 i=0, while{i<m,/ t) A# n8 B4 n/ U
    
56.                         j=0, while{j<n,
    . l/ S3 D3 V+ D0 {7 ?\" E; J
57.                                 c[i,j]=x[i,j]*y[i,j],
    ! u: _$ p+ l5 R# J; O
58.                                 j++/ x$ J4 J. a' f\" M
    
59.                         },
    , i# v  @9 y7 [  V7 @* w
60.                         i++
    / F6 H- _  |/ ]6 B) L4 [) d
61.                 },
    ( d- Z( r/ {4 W# Z% H1 f
62.                 c
    + c\" _% v: |6 J
63.         },; l( G. C& Z5 ~3 F( N) X\" w
    
64.         op==26 ://重载运算符./; k7 t& t+ u( v3 g' y  r\" e) J+ Z
    
65.         {
    7 j6 a: L! b& @3 q# [\" g& Q) }
66.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    7 H/ P0 f9 M\" i; c. H
67.                 i=0, while{i<m,+ R% L1 F3 I/ w1 ?! I
    
68.                         j=0, while{j<n,
    * g0 d9 [% G* ]& N& ]3 Z. A- k4 l
69.                                 c[i,j]=x[i,j]/y[i,j],
    $ Z2 F2 {: u2 ]  [- X( U( P
70.                                 j++
    ; k0 O. I8 o9 Y4 ^! A- h0 @
71.                         },
    . T- u; n, _9 q6 l8 a/ l9 o1 g
72.                         i++8 E% J) f: Q5 ~6 v
    
73.                 },
    - z6 g2 a* A! u& r( v
74.                 c
    , [# s* X- i8 i  |
75.         },
    5 q$ z3 a6 A& s& b5 S3 I5 j
76.         nil        //该数据类型不支持该运算符的重载，返回nil
    % |. r$ P/ M4 n! Z* ?2 e3 T+ M
77. };
    5 E! n\" Y6 g; |  b! f' G0 |& |! r+ o
78. test(:type,a,b,c)=
    / ]6 @$ V2 {7 l1 u
79.         type=mymatrix(0,0,0,-1),  //获取新数据类型' i* B# K4 c  k& o  Y+ l
    
80.         a=new[reals,2,3,data: 0.,1.,2.,3.,4.,5.],  //生成矩阵a! h; I/ W3 ~: L& D% W( \0 P, w& V$ ^
    
81.         b=new[reals,2,3,data: 1.,2.,3.,4.,5.,6.],  //生成矩阵b$ F# I  a6 S, I
    
82.         c=new[reals,3,2,data: 6.,7.,8.,9.,0.,1.],  //生成矩阵c
    : X* r+ W4 B  v
83.         o["a="], outm(a), o["b="], outm(b), o["c="], outm(c),  //输出a、b和c
    7 S% N6 `% M9 E' X7 x6 @
84.         a=cast[a,type], b=cast[b,type],  //强制转换为新数据类型
    5 E\" b( ^2 R  F3 S  _6 s- q
85.         o["a+b="], outm[a+b],     //计算并输出a+b9 Z* q( a5 [/ L. T6 |6 f  v
    
86.         o["a-b="], outm[a-b],     //计算并输出a-b! e( D0 [0 T9 N\" r: A+ J  j
    
87.         o["a*c="], outm[a*c],     //计算并输出a*c
    , U3 E5 E$ o, c. j( D3 j8 M
88.         o["a.*b="],outm[a.*b],    //计算并输出a.*b' f6 s$ I2 Q\" K$ J+ F0 s: v
    
89.         o["a./b="],outm[a./b];    //计算并输出a./b

复制代码

结果：

1. a=
   ' Q4 Q0 o( e\" |6 P2 \  U9 q( n
2. 0.  1.  2.  
   0 K+ F: o3 j6 f5 ~0 F
3. 3.  4.  5.  & f) o1 P: k) H5 \$ t0 j
   
4. b=
   7 g/ I* \\" q# P' A
5. 1.  2.  3.  
   - S6 k& [7 f5 o* a2 C/ E8 V( T
6. 4.  5.  6.  1 s! w4 f- k$ _  Z
   
7. c=/ m3 d, L$ f) d, j% t% K. R
   
8. 6.  7.  
   . L& ?- R, m\" W1 @. E
9. 8.  9.  & F, ?: o; u! R+ {! E0 \
   
10. 0.  1.  ! s2 U! `- `3 J$ ]
    
11. a+b=' e1 ?- ?' G6 v3 G8 _. O/ E# Q
    
12. 1.  3.  5.  
      R+ e\" P8 D0 v& N# D% X
13. 7.  9.  11.  
    7 @7 E9 m; g7 v
14. a-b=& w9 \3 m1 T; @0 b/ [
    
15. -1.  -1.  -1.  # X, O2 N0 x$ ~5 ~; g/ Y( }! k
    
16. -1.  -1.  -1.  \" w3 H& W( V2 G: ?
    
17. a*c=5 u. ~0 w; `$ f' ^\" x
    
18. 8.  11.  
    3 D5 F0 R% [( X* z1 `
19. 50.  62.  
    - ^/ Y, W4 m$ W' ~5 ~
20. a.*b=
    ! s( G/ P+ c. d' _: O! f
21. 0.  2.  6.  2 C+ T& ^% l1 o4 x; }
    
22. 12.  20.  30.  
    3 K9 k, i8 ^+ i\" k
23. a./b=! x4 j0 P: `3 y' b! k  l\" Y- G
    
24. 0.  0.5  0.66666666666666663  
    2 b( S/ t\" x/ W' S9 d* {\" f3 C
25. 0.75  0.80000000000000004  0.83333333333333337

复制代码

www.tgchaye.com

新的一天，心的祝福，祝福健康快乐！欢迎到我博文，喜欢的话请多多关注我吧

forcal

上面关于矩阵运算的运算符重载例子中，函数o和new也是可以重载的：

1. mymatrix(x,y,z,para,num,op:c,i,j,k,m,n,u,static,me)=which //定义矩阵运算
   2 @) @  R9 C6 H* c
2. {8 o7 z; y! p' o, B# ~9 W) i
   
3.         op<0  : return[me=newtype()],  q1 K) Z4 N' w0 _9 d% ?+ @
   
4.         op==0 : //重载运算符+
   4 |. C  x& m9 M; O+ w
5.         {
   + ]; D! Z- n; P2 t
6.                 len[x,0,&m,&n], c=new[reals,m,n].global(),! U5 Z9 f! d4 M1 N
   
7.                 i=0, while{i<m,
   8 s9 C( V% w7 s, r$ V* c1 X
8.                         j=0, while{j<n,
   , O/ o# e( x, r$ b$ j% n
9.                                 c[i,j]=x[i,j]+y[i,j],$ W5 m+ O7 K: R
   
10.                                 j++: \6 g- O5 Y5 g. r
    
11.                         },. g\" e2 ?\" D. O- ]# ^, G
    
12.                         i++\" M& k) w& P: L% v! l! Z/ G: J# O5 [
    
13.                 },) c8 q- h, q( D% N: t2 z\" ~$ T8 P
    
14.                 cast[c,me]  //强制转换为新类型me（矩阵），下同) \6 j$ H; w- l
    
15.         },
    . {; H2 ]1 A- \  n4 c% p0 Y# Y- B
16.         op==1 : //重载运算符-
    5 C- k! o6 x7 V% b
17.         {\" [+ v0 D& q! t5 ?\" X: Z+ _% ^\" |
    
18.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ! f# h5 ?\" M# T& v! u
19.                 i=0, while{i<m,: d/ L2 g% @8 v9 G: }
    
20.                         j=0, while{j<n,2 t9 r$ |1 j- `( |5 W
    
21.                                 c[i,j]=x[i,j]-y[i,j],3 E; F2 F! A3 `0 a9 O* E) g
    
22.                                 j++
    , h: V! a9 y4 E. _- K9 K$ T
23.                         },9 Y  H* v/ W7 d6 b' ^# Y0 p! _7 t
    
24.                         i++3 Z2 M9 y7 n  O) Q5 j$ u% J5 u
    
25.                 },  g! J5 I) B7 G
    
26.                 cast[c,me]  |% l3 S0 k- Z4 q  j3 n, |5 Y& B
    
27.         },9 Q+ t& g$ D; C4 G. @\" d! T  o
    
28.         op==2 : //重载运算符*
    & v+ R\" D. s$ \  o3 t\" L8 F0 j
29.         {
      x8 r$ ^: Q( P  w, l
30.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),  S6 q3 `8 C\" n! l1 z% W1 y
    
31.                 i=0, while{i<m,
    * E- z7 u: m* L
32.                         j=0, while{j<k,! B& w6 ^3 b, l! L' Q! c8 D
    
33.                                 c[i,j]=0.0,
    - z6 n4 ^* w6 j! \7 Z3 Y9 a) O% i
34.                                 u=0, while{u<n,
    1 t/ M7 g  H  ^5 x& |( s
35.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++
    6 B* t2 ?' E- }/ L% P8 b7 Y
36.                                 },. S! S, K1 r. O' X5 J: ]
    
37.                                 j++
    2 ]  [; J- ?0 ^# @\" [. _' s+ `
38.                         },. X4 j0 i+ P8 K7 r
    
39.                         i++
    & B7 T0 E* V\" D7 R2 i4 \; J2 r
40.                 },
    9 R, b' C2 c% V8 G8 _
41.                 cast[c,me]
    ) r. S' J$ @' [2 p9 l! ^6 E/ N# r
42.         },
    / N* V* t5 C! g\" o1 u3 Y1 U( h
43.         op==25 ://重载运算符.*
    4 q' |4 _: |! Z7 B$ e& v$ F) ?$ O
44.         {\" n% A8 X# x' ?\" r
    
45.                 len[x,0,&m,&n], c=new[reals,m,n].global(),2 H- Z+ B1 @) l
    
46.                 i=0, while{i<m,
    $ C4 B9 M% ^) h0 M# H; f) ~5 A
47.                         j=0, while{j<n,
      Q+ K0 B) Q: ?/ [) _5 o
48.                                 c[i,j]=x[i,j]*y[i,j],3 [& g3 p( H5 E. ^; u
    
49.                                 j++
    * m  l2 X4 i1 l: j' ^
50.                         },
    ! n+ @( W4 t1 I# U# j# [$ E
51.                         i++
    , r# S& B9 i- j' `
52.                 },
    ( z* _3 h7 [9 t8 p- V) E
53.                 cast[c,me]
    & X\" U; [4 \% Y0 J9 ]  P: w
54.         },: A! [! ]7 S2 W9 d5 Q
    
55.         op==26 : //重载运算符./
    + j  ]3 C; C, N1 e
56.         {
    ! C3 J% \2 U6 F- y3 Q( m* W8 `
57.                 len[x,0,&m,&n], c=new[reals,m,n].global(),6 Z& t. ~  Y6 S
    
58.                 i=0, while{i<m,
    - t9 a! ~$ p* Y: j0 |+ x2 M% m
59.                         j=0, while{j<n,
    , g/ @- D- X. I& h
60.                                 c[i,j]=x[i,j]/y[i,j],( }4 p+ L& q# i/ k. D2 J
    
61.                                 j++
    ' q5 k: H3 u0 B* L4 x$ O
62.                         },
    * l  j* m# X: x
63.                         i++
    + b- n1 Z& Y( G8 C
64.                 },
    ! D+ [  J: y% L) e# p, Q* v6 V+ [
65.                 cast[c,me]+ i! m0 I\" e5 F6 F, @  u7 X& X
    
66.         },
    % o+ C; ^3 y1 u' ^! ]$ P- }
67.         op==46 : //重载函数new3 B7 n' F- f5 ?/ c8 e
    
68.         {. U9 y$ |) F; x6 m
    
69.                 c=new[reals,y,z].global(), m=len[para], k=0,
    9 q! o! m\" p! p/ [\" E9 x
70.                 i=0, while{i<y,( {% D% M\" a0 ^2 v
    
71.                         j=0, while{j<z, if{k>=m, return[cast(c,me)]}, c(i,j)=para[k++], j++},
    / A( }6 C; j4 O+ j6 _
72.                         i++
    7 J7 [2 v) @+ {7 A
73.                 },% l0 M5 R9 Y, k$ V2 k
    
74.                 cast[c,me]' G: ^: F7 ^- U+ a. ^! n; F4 V
    
75.         },
    2 _6 M& D& C; W: t9 n* S\" {* [
76.         op==49 : //重载函数o4 e\" T( U' r, F0 L
    
77.         {# B' d* O\" R5 N3 c* c- |( K
    
78.                 len[x,0,&m,&n], k=0,1 b! y$ s( f! a0 m
    
79.                 i=0, while{i<m,3 a  M1 I+ A$ N2 b8 `
    
80.                         o["\r\n"], k=k+2, j=0, while{j<n, k=k+o[x(i,j),"  "], j++},+ l8 ]3 K2 r9 h3 Z. |
    
81.                         i++
    % t' P0 x9 ^5 S' c
82.                 },
    1 x1 u8 O, x, M
83.                 o["\r\n"], k+2
    4 h4 l' O* \! `) f% f) K
84.         },! T$ }% }( h  P
    
85.         nil     //该数据类型不支持该运算符的重载，返回nil/ b- c/ F8 d' H
    
86. };
    0 d, Y1 d2 m+ c3 N* \) Z& [; S6 a
87. test(:type,a,b,c)=
    - \! N% G- u6 Z* i# t: z. {
88.         type=mymatrix(0,0,0,0,0,-1),  //获取新数据类型: w+ p\" r' I5 e9 I2 ^
    
89.         a=new[type,2,3,lu[0.,1.,2.,3.,4.,5.]],  //生成矩阵a
    8 ^& h$ Q& z! _) F! \- b, d6 v0 i
90.         b=new[type,2,3,lu[1.,2.,3.,4.,5.,6.]],  //生成矩阵b
    $ U% ?& A4 Q6 R  q5 A\" _+ e3 o
91.         c=new[type,3,2,lu[6.,7.,8.,9.,0.,1.]],  //生成矩阵c! c# c. l- d5 t6 i4 ^/ ^4 p
    
92.         o["a=",a, "b=", b, "c=", c],  //输出a、b和c% C* }! F9 E1 u
    
93.         o["a+b=", a+b],     //计算并输出a+b. b* w, V% h0 U. w' W\" S/ b
    
94.         o["a-b=", a-b],     //计算并输出a-b
    - D/ x/ I; q4 C, d# Q
95.         o["a*c=", a*c],     //计算并输出a*c\" ]! M* t1 U: |( ^3 W  I
    
96.         o["a.*b=",a.*b],    //计算并输出a.*b- l7 E2 E1 ~) r9 l6 d2 q
    
97.         o["a./b=",a./b];    //计算并输出a./b

复制代码

结果：

1. a=
   3 I9 T: e8 C- I+ q1 f
2. 0.  1.  2.  / b& A8 ~6 `- O' O. D! V, n
   
3. 3.  4.  5.  3 o9 ^7 Y' f+ E$ b% l\" J
   
4. b=
   7 d4 u! s0 [4 \1 P$ w( o# @( i
5. 1.  2.  3.  
   / E\" d7 r. L1 R
6. 4.  5.  6.  
   ( ]1 E3 B/ P4 G) N7 r! ~
7. c=1 O% U. M  \- e
   
8. 6.  7.  
   , Z8 G& j6 I1 o/ q( A
9. 8.  9.  ' Z, K; P& H0 q+ O
   
10. 0.  1.  ! r4 f& G$ Q1 p( k4 x* R
    
11. a+b=
    + a/ L\" g# i' i. \8 i! T1 T
12. 1.  3.  5.  - Q2 J4 e0 A/ L6 G9 `
    
13. 7.  9.  11.  / O, |3 y- M+ m- |! K% t7 K8 g
    
14. a-b=7 k4 ?' J% l/ I7 p# H! K
    
15. -1.  -1.  -1.  
    7 o* d' T/ x' s8 ~
16. -1.  -1.  -1.  
    ; G& ]  a. E* i( q# a  P\" U% Q* l
17. a*c=
    - O. l& ?7 R- e1 T- ?$ x
18. 8.  11.  : Z$ A+ o5 o. n! U4 [
    
19. 50.  62.  
    5 p( k' a. h8 Y/ V- ~% q! f+ z' a; U
20. a.*b=8 P! y  ^2 z. k6 F3 t
    
21. 0.  2.  6.  
    6 x5 C\" F1 R# J1 T/ {. X# G5 o7 c
22. 12.  20.  30.  4 d/ q5 `9 s( P  m* G. N
    
23. a./b=
    . e( x. m4 d1 t9 i. y
24. 0.  0.5  0.66666666666666663  ! W0 T; R0 X7 p' S
    
25. 0.75  0.80000000000000004  0.83333333333333337  

复制代码

当然，在脚本中实现这些重载只是玩弄技巧，用C/C++实现这种重载才是王道，对此，Lu核心库提供了更好的支持。