Lu中的运算符重载

forcal

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

1. thetype(x,y,num,op)=which: G. t# {% n8 l
   
2. {$ H6 G' T, J3 v/ t
   
3.   op<0  : return[newtype()],/ V% r\" d$ C6 R\" L5 B' r% j9 h
   
4.   op==0 : x-y,    //重载运算符+
   + p- S; M- ?7 L5 U\" ~& i: l# H
5.   op==1 : x+y,    //重载运算符-
   . a- Q$ p8 t\" O$ G+ }
6.   op==2 : x/y,    //重载运算符*! A  ~; _# z9 n9 d) D* X8 T
   
7.   nil             //该数据类型不支持该运算符的重载，返回nil
   3 g4 D2 K0 B3 f7 h& A; U. o$ L  r
8. };- a0 ?\" b( Q1 G( ~; I% l4 t( \
   
9. test(:type,a,b)=* G7 S% A7 W: H5 B4 m
   
10.   type=thetype(0,0,0,-1),  //获取新数据类型& f/ Z9 @% `* x! M& F* v
    
11.   a=cast[3,type], b=cast[5,type],  //强制转换为新数据类型/ x# n; x' p3 J' H
    
12.   o[" a=",3," b=",5],  //输出a和b
    1 ?2 r7 z6 F0 A1 a
13.   o[" a+b=",a+b],      //计算并输出a+b，变成了a-b
    % j  d8 x' A0 o
14.   o[" a-b=",a-b],      //计算并输出a-b，变成了a+b
      g\" t. {# `\" Y
15.   o[" a$b=",a$b];      //没有重载运算符$，故输出nil

复制代码

结果：

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

复制代码

＝＝＝＝＝＝

  Lu核心库中没有提供矩阵运算，但在脚本中可以通过重载运算符来实现：

1. outm(x:i,j,m,n)= //输出一个矩阵# m  S# n6 ?4 B. [% D9 b1 r
   
2. {
   - {( {' h1 f. i/ z$ j$ m9 Y
3.         len[x,0,&m,&n],
   + b9 U  E9 m: A% M
4.         i=0, while{i<m,
     o' ?) m% O. l- Z; Z
5.                 o["\r\n"], j=0, while{j<n, o[x(i,j),"  "], j++},7 V, L- X& n2 M2 @% G- J
   
6.                 i++, B- G( @6 d! Y( u2 _
   
7.         },
   - X4 @5 J0 Y+ N+ ~1 B
8.         o["\r\n"], x
   9 z# G0 J& r7 ~! j
9. };: ~7 Y\" r5 F: Z7 Q3 _1 w
   
10. mymatrix(x,y,num,op:c,i,j,k,m,n,u)=which //定义矩阵运算. v- R5 g2 A& |
    
11. {6 n\" U' V. F$ M3 _
    
12.         op<0  : return[newtype()],
      |$ E$ d9 O\" u1 t7 G\" D\" |. |& X
13.         op==0 :        //重载运算符+
    - N/ O1 P7 H( L: S0 l! |
14.         {
    5 i5 E7 z& }' v
15.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
      J8 C# X. c  `, C5 H0 C2 Z+ h
16.                 i=0, while{i<m,+ }. a* \7 u+ T6 P9 D4 H. a9 s, T! j
    
17.                         j=0, while{j<n,/ V- H: V3 y5 B! Y0 y' q4 }
    
18.                                 c[i,j]=x[i,j]+y[i,j],\" a' S1 v* z, f1 |  z: h; ], I
    
19.                                 j++; z7 _3 u( l. v' c' h# d  |) Y
    
20.                         },
    , V* v  c# Y3 C) K\" o- S
21.                         i++/ x& P& R% T5 F+ a\" n
    
22.                 },
    ) a: d0 y! e% g0 A
23.                 c
    % z# q$ X$ ^/ l5 {# [. C
24.         },
    ! h- n& l% P7 ]% I
25.         op==1 :        //重载运算符-
    0 s: Y7 G; S4 p, n! p- }
26.         {
    * V- k: e5 X' C% s; }6 P$ y
27.                 len[x,0,&m,&n], c=new[reals,m,n].global(),8 C& I+ b3 Z& y6 t
    
28.                 i=0, while{i<m,
    0 Y2 U9 T9 G6 K) r4 a4 P2 r6 b# ^
29.                         j=0, while{j<n,
    3 z6 p4 Q/ y+ `8 k( X
30.                                 c[i,j]=x[i,j]-y[i,j],( j. p; D  [* Q: T  ^  ?  r& K
    
31.                                 j++9 j/ v1 J) e& }. V+ s+ G2 V) [0 S
    
32.                         },
    & }5 Z6 i. v, Y/ I$ F
33.                         i++8 S, c; P. K. z  j4 X
    
34.                 },
    ! a$ T2 _; ]! u2 F% x
35.                 c
    ) G# |' H+ k  _7 _8 W
36.         },0 F& D7 i$ K/ j7 L5 P1 c5 v
    
37.         op==2 :        //重载运算符*
    4 m2 L( Q7 S6 o# i  G; i, H3 g! L
38.         {+ c) V. Z3 k1 t; @1 r
    
39.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),! l) l8 r# ]) ]- u( X5 V0 r  P' C; {  o$ s
    
40.                 i=0, while{i<m,
    # V3 L  y( c0 I5 E
41.                         j=0, while{j<k,
    7 ], q, x9 r0 k+ p' m+ h
42.                                 c[i,j]=0.0,
    + L) P* R/ H: P. z
43.                                 u=0, while{u<n,
    5 ?\" p; A4 ?: o% x! j
44.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++
    \" ^+ Q, @- }0 N2 [# I\" e/ F! n
45.                                 },
    4 O) q$ ^# d5 I( u* Q6 ]
46.                                 j++
    % s/ y! P0 X5 z
47.                         },
    / U& {2 q' I. _6 l) ?- v( |2 f
48.                         i++
    ) l, g5 A7 A4 x2 z) Z
49.                 },! v9 l' z! T4 L& n; w5 H  k\" `
    
50.                 c
    $ H% _! Q* a$ l
51.         },
    * D' [( L7 ?- [+ w, X' y
52.         op==25 ://重载运算符.*
    3 b7 ^$ {: ~; l4 b, }! _0 j( ^; @
53.         {) K( L- D5 x  m\" j% b; n+ J6 r  \0 M4 _9 n
    
54.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ; ?( u1 }! O! X' D
55.                 i=0, while{i<m,. c0 {( ^2 G! n# d$ M' D
    
56.                         j=0, while{j<n,
      C& J4 @\" K6 k, H' A* |3 S0 q7 @: B
57.                                 c[i,j]=x[i,j]*y[i,j],% O5 A' V# z7 I- F/ i7 P, U
    
58.                                 j++
    / b% ^: B/ _  u( @2 n
59.                         },\" y; F% ?) s$ ^+ V' r$ ^/ a5 q
    
60.                         i++5 `: E; f/ ]3 q
    
61.                 },5 f  u' a1 I; z9 m5 a
    
62.                 c: a/ b1 d7 |- n\" X2 ~
    
63.         },( X( k, O' b' w4 }
    
64.         op==26 ://重载运算符./8 N\" \# i3 T) C$ @
    
65.         {# p& T% e4 |% s* x& O7 g\" y3 p
    
66.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ( x9 F+ N) G' J
67.                 i=0, while{i<m,
    & J! Y\" s8 ]' Z: Y/ ~( Y5 b
68.                         j=0, while{j<n,
    ! ~' ?9 u( F! E/ S) t$ U
69.                                 c[i,j]=x[i,j]/y[i,j],
    3 c1 \& W# u$ c2 N0 m
70.                                 j++
    3 @6 {, t% ]; D  l, g2 O8 W5 v
71.                         },4 I8 d7 o, j: ~4 W
    
72.                         i++
    , w0 |, d4 L: e7 s4 @2 u- L
73.                 },
    & k# A+ S1 V2 I  l* _\" J4 [
74.                 c+ ?1 [+ U& k5 p, W' I! A
    
75.         },
    * c5 w7 r' {1 @; ]
76.         nil        //该数据类型不支持该运算符的重载，返回nil
    0 J3 \# F: `' x/ i( d8 W
77. };
    $ `3 o% |, v, V) ]3 W- m
78. test(:type,a,b,c)=! r9 T# j# E. |\" J
    
79.         type=mymatrix(0,0,0,-1),  //获取新数据类型+ g0 w# f1 R, O2 a7 u. N+ F$ u
    
80.         a=new[reals,2,3,data: 0.,1.,2.,3.,4.,5.],  //生成矩阵a/ ]) w, T) O' b- @
    
81.         b=new[reals,2,3,data: 1.,2.,3.,4.,5.,6.],  //生成矩阵b
    4 o3 t$ z1 p& c, J4 o- O6 ~
82.         c=new[reals,3,2,data: 6.,7.,8.,9.,0.,1.],  //生成矩阵c! p, [* x8 u# k2 k. a9 W
    
83.         o["a="], outm(a), o["b="], outm(b), o["c="], outm(c),  //输出a、b和c! q* [+ i' k; ~\" _5 u* r
    
84.         a=cast[a,type], b=cast[b,type],  //强制转换为新数据类型
    ) }9 z4 ~( S) y, w& i\" s1 D  M
85.         o["a+b="], outm[a+b],     //计算并输出a+b
    . b- [8 m5 u/ A8 G( D7 P# L
86.         o["a-b="], outm[a-b],     //计算并输出a-b
    : x) N$ l) H& d2 W( h! E, N. O
87.         o["a*c="], outm[a*c],     //计算并输出a*c\" ?1 {3 U$ C  |8 K5 ]5 ]
    
88.         o["a.*b="],outm[a.*b],    //计算并输出a.*b
    $ l* s\" w9 ~1 N
89.         o["a./b="],outm[a./b];    //计算并输出a./b

复制代码

结果：

1. a=4 S( t& f. ]. {& ?3 D$ O/ g+ l
   
2. 0.  1.  2.  
   + L# K( A# e- D+ h; F3 g
3. 3.  4.  5.  \" m  J; d/ z! m6 f6 T2 T+ v: E( D
   
4. b=
   . R4 ~& S( z5 K0 X: v1 Z2 o& G
5. 1.  2.  3.  ; b  C6 `7 u6 N) ?9 @- _4 Q6 o
   
6. 4.  5.  6.  # S0 n4 ^& l\" \\" ~* _
   
7. c=+ d: u1 N0 D  N/ g
   
8. 6.  7.  8 \& _7 [$ t5 y7 J- p6 s, [0 x6 P. Q
   
9. 8.  9.  \" u0 J: n$ ~& V$ o
   
10. 0.  1.  
    + K' X\" ~- V0 G# C\" O+ i1 _/ w+ u
11. a+b=
    6 ]2 o7 r6 a7 G8 z2 X
12. 1.  3.  5.  # l0 ?# c1 w/ l! Q# w0 @
    
13. 7.  9.  11.  
    + u3 q6 D$ S% g6 y/ Q
14. a-b=
    3 u  O1 s5 a& d* l
15. -1.  -1.  -1.  
    & Z. U& `, [) ^: b& k
16. -1.  -1.  -1.  3 X& l. j9 L, U- u$ p* g
    
17. a*c=
    8 q; `9 \9 y0 x) J4 i+ d
18. 8.  11.  1 b0 y  |7 [% @7 }* X
    
19. 50.  62.  
    , w& `$ w% W# J) a0 k2 a
20. a.*b=# o\" h\" U/ b5 |. w/ s, l5 H
    
21. 0.  2.  6.  ' t$ z- q- ~  d. N! f- D$ `
    
22. 12.  20.  30.  
    4 I. B  w# b% Z8 g- f
23. a./b=
    3 F! J: j/ V2 A  T) Z$ U\" K
24. 0.  0.5  0.66666666666666663  
    , [$ C( o2 P: L8 _- Y
25. 0.75  0.80000000000000004  0.83333333333333337

复制代码

forcal

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

1. mymatrix(x,y,z,para,num,op:c,i,j,k,m,n,u,static,me)=which //定义矩阵运算
   4 l' k  v; I& x- |' Q
2. {8 M  X0 t# H' h- z  i1 B' ?/ e
   
3.         op<0  : return[me=newtype()],
   # m' p- H; m/ [+ F, b. _: D- M
4.         op==0 : //重载运算符+
   3 b! \\" E$ C/ m8 o& \
5.         {  o4 m) C/ c1 p$ H
   
6.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
   1 z- T. H+ y7 b. Q2 C' r
7.                 i=0, while{i<m,
   - u. Q5 b7 q5 g0 {
8.                         j=0, while{j<n,# t4 K4 M  s, ]
   
9.                                 c[i,j]=x[i,j]+y[i,j],
   1 A0 E8 Q2 r8 ?4 o0 K9 c
10.                                 j++
    3 [8 \7 t' F- M& g, G
11.                         },
    & M# c) X. T+ G0 f) s. N: `! B$ g
12.                         i++
    ; P5 \1 n$ d* _$ h* k
13.                 },3 |# O) [\" N& _5 w/ F. W+ x
    
14.                 cast[c,me]  //强制转换为新类型me（矩阵），下同1 _+ a* M: ^- M4 C' P) d
    
15.         },0 \% n' M# L' u% [( r  J
    
16.         op==1 : //重载运算符-
    , v9 D7 U: D6 f! |
17.         {
    9 g, A4 h3 [4 i9 ?+ y
18.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    / Q\" Z\" ?; x3 V
19.                 i=0, while{i<m,
    \" o$ |. _2 U5 d0 Y- Z9 \8 I0 H& U
20.                         j=0, while{j<n,
    & E$ x0 t+ o+ {) U' e
21.                                 c[i,j]=x[i,j]-y[i,j],* r; l. Z/ ]# m2 W( \
    
22.                                 j++! `1 R8 R\" L( t. G1 ?
    
23.                         },
    * Z, P  [3 i+ _* \
24.                         i++
    1 e* I( x6 r% F) O* {8 N
25.                 },
    $ F( A8 v9 P4 c) i2 f2 ?, S
26.                 cast[c,me]
    $ x9 y0 H. S* p3 w/ B8 b
27.         },- v$ o, U0 J; h3 g8 Y
    
28.         op==2 : //重载运算符*
    - c* U( t% n9 X. I9 h) E
29.         {
    \" s- W2 a* o# S: v$ I, a
30.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),1 @0 {- H3 |& h8 T4 G% ?% M
    
31.                 i=0, while{i<m,
    ) w* [. \: x9 H# e' N
32.                         j=0, while{j<k,0 B( J' R: @1 z  T0 ^0 U
    
33.                                 c[i,j]=0.0,
    / C3 @6 o0 H+ o( U
34.                                 u=0, while{u<n,
    % p3 |8 F. Z# w6 C; ^' X! K
35.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++\" |\" D7 K1 Z\" Z# g1 H1 H
    
36.                                 },, u* r* \; ^9 [
    
37.                                 j++
    & e* [2 e. Z- @1 y7 L8 s
38.                         },
    % z/ a( d+ C: J5 F4 v
39.                         i++
    3 Q7 r; `# J: r; C2 L
40.                 },' ]& K$ _. s4 |7 p- }9 n\" M/ R
    
41.                 cast[c,me]
    * M9 n6 U+ H' c  b1 U$ ~
42.         },/ s% K$ a5 p% }* E: b
    
43.         op==25 ://重载运算符.*
    ) B/ z+ Z! O; P6 Q5 Z& n+ v& o
44.         {& K6 _$ B0 r9 Y8 y
    
45.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    # C0 f/ r& B6 p0 p9 U' p! @2 ~
46.                 i=0, while{i<m,
    ( q- O6 p2 n! ?: h% c1 G& ^
47.                         j=0, while{j<n,
    ' j$ _; a% r: z* u; I' _5 G
48.                                 c[i,j]=x[i,j]*y[i,j],
    ! `* n9 V! O/ G4 Q\" M0 y
49.                                 j++) c- q; S& v  u2 _3 w0 x
    
50.                         },
    + \9 X1 \8 z6 W7 V: U# R
51.                         i++
    ) q- h/ p) `% Z( Y8 x( L' Q
52.                 },* {. I* A3 h$ S. t& c# D# W
    
53.                 cast[c,me]2 _8 ]! }9 P* A5 q$ f9 ^
    
54.         },
    8 L4 _\" N\" `0 u0 c  `, P
55.         op==26 : //重载运算符./
    * m9 _. l! o- n  u+ g2 s! b, @
56.         {, b/ F4 \2 ]; `6 H
    
57.                 len[x,0,&m,&n], c=new[reals,m,n].global(),4 }% ~, D\" G/ y* u* M: q' J\" R4 k1 o
    
58.                 i=0, while{i<m,
    + {- W\" I# [# W' y$ d3 ^
59.                         j=0, while{j<n,
    $ z5 }: J0 m8 X2 }2 Z% V
60.                                 c[i,j]=x[i,j]/y[i,j],9 O- k1 M) M/ F( {  S+ {
    
61.                                 j++
    ; J' u# D/ Y7 G9 X( ?+ r\" a( e  P
62.                         },
    % L- s$ l8 k( Z# }' k$ O$ J
63.                         i++
    0 A7 p0 m  b7 _
64.                 },6 n( H0 B' ?; V# R: t1 l
    
65.                 cast[c,me]2 p$ m$ }3 j6 S2 G
    
66.         },# B+ \' d- {: z3 h1 ?
    
67.         op==46 : //重载函数new0 R7 e7 s5 C  D7 e' Z\" ]
    
68.         {
    & t\" B! Q  m) I  [, i  o* _
69.                 c=new[reals,y,z].global(), m=len[para], k=0,7 Y! K) Q6 k  K: r: d
    
70.                 i=0, while{i<y,
    ( w/ p! z  y8 \% {6 p\" P1 k1 p
71.                         j=0, while{j<z, if{k>=m, return[cast(c,me)]}, c(i,j)=para[k++], j++},& ]: Y8 b% c6 ~
    
72.                         i++3 Z' k- \2 z7 h3 Z9 s. K
    
73.                 },. d' {' t, h  V/ e# S) d8 N. j' y5 o
    
74.                 cast[c,me]& d) j/ f8 {# h7 u7 W
    
75.         },
    5 I6 J2 k* ~# M
76.         op==49 : //重载函数o
    1 k9 W5 ~. S8 n7 l! }
77.         {  f; w+ R8 \3 X! }+ B
    
78.                 len[x,0,&m,&n], k=0,
    & Y# I5 A- i8 A! c
79.                 i=0, while{i<m,, n3 N, h# ]' d* [: g
    
80.                         o["\r\n"], k=k+2, j=0, while{j<n, k=k+o[x(i,j),"  "], j++},5 [% r& A3 p6 b! L\" |, r( y
    
81.                         i+++ P0 c; S4 @  X$ l1 i
    
82.                 },
    ) Y8 `* Z( ^# Y
83.                 o["\r\n"], k+2
    4 w1 v  @: o3 f) m1 E
84.         },
    & r( k2 @+ m3 h- z
85.         nil     //该数据类型不支持该运算符的重载，返回nil! b# W3 T( V9 |; U4 m* ?8 T+ e* B
    
86. };\" ~3 d* l, j; J2 M( E: L
    
87. test(:type,a,b,c)=) w. k' p\" v\" H! J5 c0 ^
    
88.         type=mymatrix(0,0,0,0,0,-1),  //获取新数据类型
      P\" \- t- T( Z! l% ]
89.         a=new[type,2,3,lu[0.,1.,2.,3.,4.,5.]],  //生成矩阵a
    # [\" Z' L3 F0 ^2 t
90.         b=new[type,2,3,lu[1.,2.,3.,4.,5.,6.]],  //生成矩阵b2 @0 ^1 I8 i1 {8 a$ g& E2 i4 B! I- [
    
91.         c=new[type,3,2,lu[6.,7.,8.,9.,0.,1.]],  //生成矩阵c  j9 W$ ^3 g/ o( b
    
92.         o["a=",a, "b=", b, "c=", c],  //输出a、b和c# `- k; j\" d) H2 A4 d  m
    
93.         o["a+b=", a+b],     //计算并输出a+b/ x- e0 f. k& l: l
    
94.         o["a-b=", a-b],     //计算并输出a-b
    ) }1 ?% g' |) i+ o6 [
95.         o["a*c=", a*c],     //计算并输出a*c
    9 }0 q6 ^# {! Y
96.         o["a.*b=",a.*b],    //计算并输出a.*b
    ) @+ k% [9 i* d+ U. M7 B% r  n- R
97.         o["a./b=",a./b];    //计算并输出a./b

复制代码

结果：

1. a=0 t9 I/ V% I0 g3 O0 F  H& t
   
2. 0.  1.  2.  2 `' s: Y4 ?( y: e: x# B0 @1 Q
   
3. 3.  4.  5.  ! r/ J4 e: E: O# A
   
4. b=
   ! k: ~: `; h/ K! A. D; K
5. 1.  2.  3.  
   ' f; O/ k) }& ?3 Y1 A: F; Y
6. 4.  5.  6.  & Z8 i' T' O$ Y0 U3 F1 A$ a
   
7. c=; `- q: G* U4 d6 X% y# k\" @
   
8. 6.  7.  2 h- k1 Y# B6 m0 a# T) e
   
9. 8.  9.  
   : E: X! V3 C; C. B, A' D: h0 o2 m* s
10. 0.  1.  1 a/ I4 e0 G/ _: U; o1 f7 m
    
11. a+b=4 D1 P  H9 h! k
    
12. 1.  3.  5.  & e6 b& V5 D9 b
    
13. 7.  9.  11.  9 x: Y9 H0 U4 e5 J% d+ T
    
14. a-b=
    & s& X: q) C# u9 @6 j; a. v
15. -1.  -1.  -1.  
    ' \( C6 e& Q5 H/ z7 V
16. -1.  -1.  -1.  
    0 [5 _( o* A$ `# b- c$ W( Q
17. a*c=
    2 K% I# s. y& f. {9 Z) Q, X
18. 8.  11.  & J9 y. L% [. ^7 k
    
19. 50.  62.  ( Y% V. O+ u* m5 O
    
20. a.*b=+ W8 x' |5 X, u' r5 k, I
    
21. 0.  2.  6.  % @7 K# A9 Z6 z
    
22. 12.  20.  30.  ) x1 p) R/ z0 h  z( \  \6 I/ ^\" O$ w2 U
    
23. a./b=
    0 g; K! p3 U# s1 s
24. 0.  0.5  0.66666666666666663  * v4 X/ {* f, v0 @) S$ L. ?% P; V
    
25. 0.75  0.80000000000000004  0.83333333333333337  

复制代码

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

www.tgchaye.com

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