Lu中的运算符重载

forcal

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

1. thetype(x,y,num,op)=which
     K- {% j! E9 D( d8 a
2. {
   $ x% e( i% \0 n
3.   op<0  : return[newtype()],- S2 M+ y2 ?0 ?! W8 @
   
4.   op==0 : x-y,    //重载运算符+
   $ v* n+ H: c3 C2 Y% v1 q
5.   op==1 : x+y,    //重载运算符-  z7 x2 Z- `- E- ^5 r; `5 z) k
   
6.   op==2 : x/y,    //重载运算符*9 y' l. x& \( t# t* w+ R8 Q9 c
   
7.   nil             //该数据类型不支持该运算符的重载，返回nil
   : {' f7 `5 A1 c8 `. D2 O  n\" p
8. };
     Z$ R3 s8 ?0 a5 j
9. test(:type,a,b)=\" r7 q  ]  D\" X+ `( i
   
10.   type=thetype(0,0,0,-1),  //获取新数据类型4 p0 h$ U( {; R5 W
    
11.   a=cast[3,type], b=cast[5,type],  //强制转换为新数据类型% M& H. b  J, @% l* Q7 x, @
    
12.   o[" a=",3," b=",5],  //输出a和b\" Z, m2 r' a( Y! u
    
13.   o[" a+b=",a+b],      //计算并输出a+b，变成了a-b* C  [7 B$ ^4 \: `1 F
    
14.   o[" a-b=",a-b],      //计算并输出a-b，变成了a+b\" g% V( l$ n+ s
    
15.   o[" a$b=",a$b];      //没有重载运算符$，故输出nil

复制代码

结果：

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

复制代码

＝＝＝＝＝＝
. n2 D4 f  _+ F, o% e: D+ S. V
' `2 }+ `, f9 @  Lu核心库中没有提供矩阵运算，但在脚本中可以通过重载运算符来实现：

1. outm(x:i,j,m,n)= //输出一个矩阵& z% n  v0 |, z5 T+ D
   
2. {! H+ g0 i& r' B3 C3 H( v  o
   
3.         len[x,0,&m,&n],  \0 n4 ^9 Z) K# D\" N
   
4.         i=0, while{i<m,
   * d8 W0 i' h4 i0 F2 V
5.                 o["\r\n"], j=0, while{j<n, o[x(i,j),"  "], j++},0 R: W\" q0 k& g6 L1 ~+ Q! Z# U
   
6.                 i++# o/ l2 I% n: z
   
7.         },8 H* U% o- f8 E0 c
   
8.         o["\r\n"], x
   * m' O) q) v# x% T3 m. P
9. };
   ) U. G1 H+ f! V, Q3 I1 r7 s
10. mymatrix(x,y,num,op:c,i,j,k,m,n,u)=which //定义矩阵运算: F) r/ p; A\" B8 F: z
    
11. {! D( J& G- P' T4 D* e3 v. L
    
12.         op<0  : return[newtype()],
    9 O' O8 {$ M# ?\" C: D
13.         op==0 :        //重载运算符+
    ' W2 N4 C2 V/ R) \4 k/ k: }3 h, d
14.         {  k1 v% K. g! e9 m% i6 T
    
15.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ( z6 }2 Y7 \( D+ H! d
16.                 i=0, while{i<m,8 D7 P' o( y- R6 h& W
    
17.                         j=0, while{j<n,8 F1 y6 i/ v. }. ]* u# e\" L
    
18.                                 c[i,j]=x[i,j]+y[i,j],! y6 r5 X/ I5 x\" j! s  ?
    
19.                                 j++2 f; ~; z. V( T. n! f8 C9 V
    
20.                         },7 Y# U2 Q( ^, K! }' S
    
21.                         i++
    ( b8 j+ A2 Y; c* e, {  P
22.                 },
    + E# t+ a: ]) D9 {3 |1 \\" r! l
23.                 c
    0 t' A9 l% ?) g8 T) ?, a1 d
24.         },3 _* Q; l8 R5 V
    
25.         op==1 :        //重载运算符-
    , Q/ o7 w+ y  I, [\" @: ?, |
26.         {
    % }4 G( p) F\" Q' L
27.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ) `; p  h5 s5 W/ l  I* d! ]5 E
28.                 i=0, while{i<m,# x5 W& V- a6 N
    
29.                         j=0, while{j<n,6 ^- f. e8 p1 K0 u: n7 N2 K9 X
    
30.                                 c[i,j]=x[i,j]-y[i,j],( m3 E3 W6 ?7 g9 S0 m; @) N
    
31.                                 j++
    ! g, F' a  J$ N* I5 I\" r
32.                         },4 R0 ^# F& d( i; Q6 M; e! S
    
33.                         i++6 N0 X3 ~: b$ R0 p) G/ Z# H2 V\" K
    
34.                 },
    , e+ @, d- \. @% [
35.                 c
    2 Z- Y! F' v2 F- J( C2 q
36.         },$ X/ E9 e  ?( D7 N4 ]# o
    
37.         op==2 :        //重载运算符*4 T6 q& T4 _2 _5 R! C1 U\" D; b; u
    
38.         {3 T: o5 }6 R$ k3 S
    
39.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),
    ; ?- d8 K\" c8 X1 |9 @1 K; ^; C
40.                 i=0, while{i<m,! F; p8 N% l: D\" g9 {, M9 B
    
41.                         j=0, while{j<k,
    * R  Q! c4 N' q; S0 `
42.                                 c[i,j]=0.0,2 l! G( A( d4 S8 O/ O% |' X
    
43.                                 u=0, while{u<n,# w; w+ C$ k( v\" d4 r: [$ m6 l
    
44.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++
    & A% H% T( ?3 Q7 x: ~
45.                                 },9 l& X% a+ ]* B' j
    
46.                                 j++
    ! p- G5 N) }- c) s+ C9 e9 |, C
47.                         },
    ! S) y6 R\" b\" c% x, _, i) o
48.                         i++. n$ |) g& W: w  }, g* v\" k) ~5 J4 k
    
49.                 },
    5 K, _  N# g8 f. `/ Q/ E
50.                 c
    & D. Y! V* Q\" u5 ?3 T  `$ x% `
51.         },
    \" m# C5 m0 R9 s' s: V, Q8 ?5 R
52.         op==25 ://重载运算符.*# O- G. _8 s3 G# G3 V+ W3 S
    
53.         {
    + M, `) ?  i3 [! w
54.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    & a* k9 j5 i. h# n; L
55.                 i=0, while{i<m,
    * @* I9 ?  i$ p6 i
56.                         j=0, while{j<n,
    # q% `, k( F9 P  {0 |( U
57.                                 c[i,j]=x[i,j]*y[i,j],) t$ l& @' }8 e+ f* t
    
58.                                 j++$ d, t$ a( i- P+ o% G
    
59.                         },/ V. E% l\" w$ J' s
    
60.                         i++
    ! B& X4 N1 V8 M2 Q
61.                 },. Y- q. W5 R3 l
    
62.                 c+ @( c, `3 h$ L* A5 M) M
    
63.         },' L! o$ P3 H7 F\" V% L! l
    
64.         op==26 ://重载运算符./* A& @% G; \. G4 X: R3 T9 q
    
65.         {
    4 \& y& Q# n, g* t
66.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    4 p0 Y: h3 O\" P7 R7 I
67.                 i=0, while{i<m,5 Y6 X( W8 r* P+ R\" w\" T$ R6 u
    
68.                         j=0, while{j<n,
    7 S, n% ]9 y3 D8 q; d$ [
69.                                 c[i,j]=x[i,j]/y[i,j],
    + d4 p) W  b4 `
70.                                 j++
    , d+ _+ |/ ~+ ?, ?6 l
71.                         },
    5 `! o+ e\" L6 k8 u+ x
72.                         i++
    2 ?  t! P$ J/ P! D4 E0 W
73.                 },
    & Y) I( A' e7 E7 I/ i
74.                 c2 K' x1 s: a4 p/ U+ k: W
    
75.         },
    ; P/ N/ h$ O0 [
76.         nil        //该数据类型不支持该运算符的重载，返回nil
    + U4 f. ^5 S+ G& x
77. };4 L# `; T  x2 S. @  _
    
78. test(:type,a,b,c)=7 u9 N( `& E  C7 d
    
79.         type=mymatrix(0,0,0,-1),  //获取新数据类型
    $ r# E% W# V\" T; M\" o0 f5 r
80.         a=new[reals,2,3,data: 0.,1.,2.,3.,4.,5.],  //生成矩阵a% ]- S! }$ _; u6 b# J( u* U
    
81.         b=new[reals,2,3,data: 1.,2.,3.,4.,5.,6.],  //生成矩阵b
    ; n7 B. ^) ^' l3 j& J
82.         c=new[reals,3,2,data: 6.,7.,8.,9.,0.,1.],  //生成矩阵c- c' P, l. ^4 ?& n& g0 l
    
83.         o["a="], outm(a), o["b="], outm(b), o["c="], outm(c),  //输出a、b和c
    ) B* x+ M4 v\" s
84.         a=cast[a,type], b=cast[b,type],  //强制转换为新数据类型. S2 n; x/ l! b  [
    
85.         o["a+b="], outm[a+b],     //计算并输出a+b
    ! p* @$ O$ Q5 n8 i
86.         o["a-b="], outm[a-b],     //计算并输出a-b
    ( T# Y8 i\" r  p! k) x7 e
87.         o["a*c="], outm[a*c],     //计算并输出a*c1 W& \+ q& O( R
    
88.         o["a.*b="],outm[a.*b],    //计算并输出a.*b9 z: J; {& ^; G5 S3 n2 S; \
    
89.         o["a./b="],outm[a./b];    //计算并输出a./b

复制代码

结果：

1. a=
   ) R  q\" y( [8 n4 `
2. 0.  1.  2.  \" z! ?/ E. V' T
   
3. 3.  4.  5.  6 M4 _2 f) b$ e6 V( k1 g
   
4. b=
   ' D+ }0 @& k; g& @
5. 1.  2.  3.  : T* C$ R1 e6 a8 k. V
   
6. 4.  5.  6.  
   ) v8 O( c' ?4 W
7. c=: M  ?* N# F2 A
   
8. 6.  7.  
   : M. `; J2 i/ d$ O% a
9. 8.  9.  
   % F& o5 X7 V! C\" F4 }8 h\" b
10. 0.  1.  
      q' s- G/ N' y3 ^1 l% E
11. a+b=
    , q8 R- A% \$ K\" O6 P
12. 1.  3.  5.  
    ; c2 l3 E: L/ U$ i/ K+ \+ K
13. 7.  9.  11.  5 q0 M$ O6 A& X- y
    
14. a-b=- n9 h( @9 T+ {5 j8 m
    
15. -1.  -1.  -1.  
    3 X5 e& O; ]+ m6 H$ F' }# e
16. -1.  -1.  -1.  - ]7 v  T- z3 u6 u* D/ d4 g
    
17. a*c=: B7 Q+ r% r6 B# i3 [5 ]  g
    
18. 8.  11.  
    0 A  X! ^5 Y2 R2 V! w
19. 50.  62.  * x; f- F+ d6 h7 n5 |
    
20. a.*b=  |7 u4 z* p! Q4 p2 p7 j
    
21. 0.  2.  6.  2 Z- K- L# h, W/ ?/ r
    
22. 12.  20.  30.  ! e) q* ]5 j/ R8 B/ G) R
    
23. a./b=7 F+ j) W; b8 Y& ~4 f* ]4 [  i' S0 u
    
24. 0.  0.5  0.66666666666666663  
    ' R& v2 B9 q# E5 F9 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 //定义矩阵运算5 Y# U( t% n- V* g( H/ R
   
2. {* s; P; i9 Z* h- h
   
3.         op<0  : return[me=newtype()],
   2 N$ H. x+ [+ B
4.         op==0 : //重载运算符+% E* C1 n8 g$ f5 ?& L4 l
   
5.         {2 b# g: i, a( B1 Q
   
6.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
   8 t7 N2 e0 e* B
7.                 i=0, while{i<m,* K# C& E) a\" p' ?& f
   
8.                         j=0, while{j<n,
     D: E) B1 E  ^
9.                                 c[i,j]=x[i,j]+y[i,j],
   / \3 v) m! I1 y4 G2 f( @
10.                                 j++; B2 ?. Z/ s* y% B5 @
    
11.                         },
    * X, d4 |8 a5 {, w' X/ E
12.                         i++
    4 q: P- H$ o. H\" J: ^$ L) W3 M( \
13.                 },
    ; h& K* ?- x8 l+ \, j# C$ Y
14.                 cast[c,me]  //强制转换为新类型me（矩阵），下同
    . A% b/ A0 x$ r$ u
15.         },\" z$ P2 P& ^, R, Z) B& D( j8 x
    
16.         op==1 : //重载运算符-/ G- S- v0 A( D4 P+ x
    
17.         {
    ( j\" E  A& t2 p8 s  u/ t* p
18.                 len[x,0,&m,&n], c=new[reals,m,n].global(),\" b4 U+ Q( N8 A# i0 N
    
19.                 i=0, while{i<m,
    : t7 Q: [3 v, p  S; V
20.                         j=0, while{j<n,+ F1 e: _) X  z) t& Q
    
21.                                 c[i,j]=x[i,j]-y[i,j],
    0 y! o, z: }' B( S6 y. S* j
22.                                 j++. u- z1 E1 g+ u# k6 M  M7 I3 s
    
23.                         },
    : d; f! J: s$ b0 e/ I
24.                         i++, c+ _( \- }7 X$ M
    
25.                 },4 a# m+ x, ?8 r
    
26.                 cast[c,me]
    ! _- g3 E! S- Q7 _  c+ |& M
27.         },: h0 k5 v\" B3 M6 C: Q7 B  b9 R
    
28.         op==2 : //重载运算符*1 o' e: G1 O' Y/ ]% _+ p. w+ n  u
    
29.         {3 H: B; r# n; q; @/ v0 d
    
30.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),
    . M% H7 M2 R3 Z/ p/ ]0 h, f
31.                 i=0, while{i<m,
    ! U: R) c: @+ T: f9 S1 B+ q
32.                         j=0, while{j<k,
    6 g! j) T) H9 F3 {* O
33.                                 c[i,j]=0.0,
    ; e1 J9 F6 J. c5 S+ w' {) w6 ~  x
34.                                 u=0, while{u<n,& U0 P, }; }: O
    
35.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++7 a0 g& P# I4 `( S\" U9 I
    
36.                                 },' `( I' N, H! l
    
37.                                 j++6 d5 E5 x! s! m
    
38.                         },
    ( L+ m4 ~; v- I, H+ _7 s
39.                         i++, R. a3 N& o$ F0 E2 a
    
40.                 },* l/ g, s5 W4 ]: Q; R
    
41.                 cast[c,me]9 a7 _# H5 ~5 }
    
42.         },
    7 }3 U( E! m8 u3 g( h\" ~7 v. N
43.         op==25 ://重载运算符.*( w. _. b\" {! |0 x: e& q% f
    
44.         {3 N5 e, v. _) z* w. W
    
45.                 len[x,0,&m,&n], c=new[reals,m,n].global(),6 W/ W- M( Y5 E8 w0 z  U/ x, S
    
46.                 i=0, while{i<m,
    6 `7 A/ }1 b& k3 g- {- T' Q0 C
47.                         j=0, while{j<n,
    1 ^7 n. e9 s- Y
48.                                 c[i,j]=x[i,j]*y[i,j],
    7 _+ F. Z( V+ q# w$ R1 [# T/ p, Z
49.                                 j++
    8 s) f2 F4 p' T- _/ ]
50.                         },
    * Q( S2 N- B  Z' T
51.                         i++# y8 H' @  w' I
    
52.                 },* a1 |9 x( j3 k
    
53.                 cast[c,me]# Z2 A+ M. Q: Q: p$ M2 F
    
54.         },  ^: F. J- H+ }$ u9 i
    
55.         op==26 : //重载运算符./
    1 X, X+ r7 b  B: C$ e- F4 b2 S
56.         {8 |9 m\" N8 x+ S) D. m( ]8 k, y
    
57.                 len[x,0,&m,&n], c=new[reals,m,n].global(),1 Z! Z# w4 s5 X
    
58.                 i=0, while{i<m,
    , f- F* s: U1 L2 L
59.                         j=0, while{j<n,
    # k5 P/ \/ p' [6 v
60.                                 c[i,j]=x[i,j]/y[i,j],
    / \7 m3 R1 y( i1 W/ V$ J, i
61.                                 j++\" l* _  o$ z; g) ], i2 A& O7 O! u3 s
    
62.                         },
    + I# _% W/ \$ h9 v7 S/ f
63.                         i++2 t+ k4 I& R7 U0 q# ]/ U6 ~
    
64.                 },
    + i' W& T! \2 X  K0 ~* \* |
65.                 cast[c,me]0 |\" f( a\" c) A6 H0 R# [6 n5 C4 L
    
66.         },7 e  U# T! B6 k8 p
    
67.         op==46 : //重载函数new
    : P' ^6 j% O# K4 L% @
68.         {
    0 E5 `, e7 P0 e4 f1 _
69.                 c=new[reals,y,z].global(), m=len[para], k=0,% @* e3 A\" x& W, `# h
    
70.                 i=0, while{i<y,
    9 o1 l: H& s6 n# p2 O; c
71.                         j=0, while{j<z, if{k>=m, return[cast(c,me)]}, c(i,j)=para[k++], j++},4 ~2 R* x% p9 u. a- V. Z
    
72.                         i++  Q  E- {\" Z9 G9 f& m  s7 k& F
    
73.                 },* S; J% [; A  b7 ^& a+ }' J% T
    
74.                 cast[c,me]
    : L& t4 o\" D9 ]* V  P
75.         },' j0 [# ~7 D- e# r) ~
    
76.         op==49 : //重载函数o, d3 q, M: ]! i9 ]\" I. Q
    
77.         {% O0 q4 b2 m! I% u8 F0 r' y
    
78.                 len[x,0,&m,&n], k=0,* I8 `9 Z7 o1 T( r8 \* V
    
79.                 i=0, while{i<m,
    5 e& I, x7 o1 M7 e4 F3 f! }\" `* E
80.                         o["\r\n"], k=k+2, j=0, while{j<n, k=k+o[x(i,j),"  "], j++},
    3 Q5 K3 r# T& {) Y2 I9 R
81.                         i++
    6 b: t  @; u* g, M- k9 S
82.                 },
    2 W# }. m! ?, C( j( e4 F4 I7 L
83.                 o["\r\n"], k+2& C: X! V0 `1 B6 z
    
84.         },
    8 @\" T1 t. b7 Q* G/ f. S# H8 a  Z
85.         nil     //该数据类型不支持该运算符的重载，返回nil) `1 T9 |( r\" Y5 f: P
    
86. };
    $ y6 Z: b$ `( Z; Y+ i
87. test(:type,a,b,c)=/ N% O3 N  p  v* @/ _
    
88.         type=mymatrix(0,0,0,0,0,-1),  //获取新数据类型\" w; f: W\" R/ a) k. \+ B
    
89.         a=new[type,2,3,lu[0.,1.,2.,3.,4.,5.]],  //生成矩阵a3 t9 V4 O2 _3 P. r7 U
    
90.         b=new[type,2,3,lu[1.,2.,3.,4.,5.,6.]],  //生成矩阵b
    ( ~4 K9 v  g' h. l. g0 B
91.         c=new[type,3,2,lu[6.,7.,8.,9.,0.,1.]],  //生成矩阵c
    % [/ ?- g' [7 w0 v, z6 |
92.         o["a=",a, "b=", b, "c=", c],  //输出a、b和c6 p3 ~/ r0 E# |/ m
    
93.         o["a+b=", a+b],     //计算并输出a+b
    * n. E/ {- G' \) h
94.         o["a-b=", a-b],     //计算并输出a-b# h9 k+ n6 z& {, x1 z3 Y
    
95.         o["a*c=", a*c],     //计算并输出a*c; X% b# O  P2 r, X7 `# e
    
96.         o["a.*b=",a.*b],    //计算并输出a.*b
    \" G9 W+ h3 T: D1 d2 B! P4 k: I, u8 i
97.         o["a./b=",a./b];    //计算并输出a./b

复制代码

结果：

1. a=1 Z/ F# Z9 Y, {- |' h
   
2. 0.  1.  2.  + E1 O! [& x6 g5 q9 B3 b. l, P
   
3. 3.  4.  5.  
   5 m* R+ G* c) ~- [) Y7 Z; l
4. b=
   % G* Q. Q7 J  r8 P6 n5 A  [2 m
5. 1.  2.  3.  
   3 j( D. ~8 l% J  k0 m) {* B) H
6. 4.  5.  6.  
   ( o/ ?0 e8 ?! d# R0 {7 x$ [0 ~
7. c=4 y& B5 J0 N' s9 Y5 j# j/ d: _
   
8. 6.  7.  
   ' n# v' ~1 D0 u! i7 k7 G7 e
9. 8.  9.  
   / c6 m! m9 B+ y( v& c\" ?: `
10. 0.  1.  5 E6 Q$ \# W! n+ V3 L
    
11. a+b=. f5 G+ B' v; L+ Z9 @  H\" |  }
    
12. 1.  3.  5.  
    3 u0 S3 J, L% w! |$ p' u# Q3 T
13. 7.  9.  11.  
    7 m3 |3 j5 A4 a: \( _* y
14. a-b=
    \" E7 o5 l9 {\" V- H2 p+ [+ I- {
15. -1.  -1.  -1.  
    \" x3 @0 @. k; s6 r; b7 `
16. -1.  -1.  -1.  . D8 `9 E* U: q! e( g+ O/ @
    
17. a*c=5 k4 N2 x0 R1 o6 m  [
    
18. 8.  11.  : \8 |$ Q) L- U8 A
    
19. 50.  62.  ; W3 W+ {5 x  `
    
20. a.*b=7 l5 Q0 S  R2 q% n$ |& m
    
21. 0.  2.  6.  ' Y0 n) X; c. U: l3 D3 F& [
    
22. 12.  20.  30.  
    8 k9 I1 m2 s! a0 q
23. a./b=
    ! y4 U) s& _* ?/ N$ C\" W8 @
24. 0.  0.5  0.66666666666666663  
    ' i1 J( S4 a+ N6 v
25. 0.75  0.80000000000000004  0.83333333333333337  

复制代码

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

www.tgchaye.com

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