Lu中的运算符重载

forcal

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

1. thetype(x,y,num,op)=which
   % T# d3 \7 S( i. }
2. {( B0 U: i( {1 i$ Y% Z/ V9 R: L
   
3.   op<0  : return[newtype()],% }; b5 z8 d+ Q0 g3 U6 S* I
   
4.   op==0 : x-y,    //重载运算符+# t7 r5 g. W4 [* `
   
5.   op==1 : x+y,    //重载运算符-
   % o) u0 e3 d$ \\" m$ m6 o
6.   op==2 : x/y,    //重载运算符*
   : F$ _5 X* d1 `# W0 n
7.   nil             //该数据类型不支持该运算符的重载，返回nil
   8 u9 T3 H. C4 ^7 Z0 O  J+ ]\" s
8. };
   % V7 h1 b; Z# H6 r0 G
9. test(:type,a,b)=: t1 T* K4 V# {! |
   
10.   type=thetype(0,0,0,-1),  //获取新数据类型2 }- G. |7 D; x& T+ q9 A
    
11.   a=cast[3,type], b=cast[5,type],  //强制转换为新数据类型
    / X6 w' _$ Z! m/ i2 q0 A( E
12.   o[" a=",3," b=",5],  //输出a和b' j, D! @& y! O1 Y* R0 B
    
13.   o[" a+b=",a+b],      //计算并输出a+b，变成了a-b
    . V& M9 P/ p) T: `
14.   o[" a-b=",a-b],      //计算并输出a-b，变成了a+b
    & |6 u\" B  F4 ]0 `  e2 _
15.   o[" a$b=",a$b];      //没有重载运算符$，故输出nil

复制代码

结果：

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

复制代码

＝＝＝＝＝＝
! p' I& i' w- v  N( O& w) \7 Q
. u% \( d, G/ s+ R; E  G4 r7 z/ }  Lu核心库中没有提供矩阵运算，但在脚本中可以通过重载运算符来实现：

1. outm(x:i,j,m,n)= //输出一个矩阵; Q% M$ V) p1 `, h; Z5 R
   
2. {\" `9 H: V$ M' p- D: {. p
   
3.         len[x,0,&m,&n],  _( C, f6 N0 u
   
4.         i=0, while{i<m,- x4 D6 a# K) a\" v2 f# I
   
5.                 o["\r\n"], j=0, while{j<n, o[x(i,j),"  "], j++},
   3 @. T; F9 ^, D) @- T: v
6.                 i++
   5 E- s# z1 e( A1 {/ w4 g
7.         },  h5 ^$ u/ q# [\" J4 O
   
8.         o["\r\n"], x4 m; I, m8 k! E. ^2 n
   
9. };+ P9 Q0 Q+ B7 S! x: u% s9 c7 M
   
10. mymatrix(x,y,num,op:c,i,j,k,m,n,u)=which //定义矩阵运算3 v' R8 q* c  c! M
    
11. {
    ) R) D2 x. s  |' S. s/ s# @* z! i
12.         op<0  : return[newtype()],, v\" N/ c9 q4 h# [+ ^+ o
    
13.         op==0 :        //重载运算符+
    : N4 u; e2 y& F
14.         {( o0 E, p& [1 h
    
15.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ! f4 F4 \6 N; w' w! }4 Y9 i
16.                 i=0, while{i<m,2 z$ m- d: Q* ?
    
17.                         j=0, while{j<n,
    # O  p$ }: B! R\" L
18.                                 c[i,j]=x[i,j]+y[i,j],
    / a; G0 ?# n# V: h' i9 e8 d2 V
19.                                 j++
    2 a6 y) l8 b2 T& I
20.                         },/ s0 W: \. Y0 e8 k  }- e( J  n
    
21.                         i++
      i5 l; k7 G5 j1 T# v
22.                 },  V# {8 V4 M3 Z6 f( V+ f  ~
    
23.                 c! x9 \: ]6 l( W8 S# d4 A: R
    
24.         },
    ' y) T$ f' |+ t
25.         op==1 :        //重载运算符-
    / y0 `3 F$ g- F- D5 |- H7 z( i+ f
26.         {/ l& k7 z8 L) f& X
    
27.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    & t2 U6 w6 V, Q4 V, r
28.                 i=0, while{i<m,. W9 `\" T3 G% g
    
29.                         j=0, while{j<n,. u$ e/ U+ q& l% u, O9 S
    
30.                                 c[i,j]=x[i,j]-y[i,j],: m/ D* K: ]4 K( |
    
31.                                 j++  h2 E% K0 F8 D, K* j
    
32.                         },$ @7 y  e# p2 @0 v/ N$ R
    
33.                         i++, H# K1 c# n# H& f; H$ ~
    
34.                 },' |2 H. ~. d' e) L- U$ g
    
35.                 c0 Q1 ?/ a! K6 o8 V# J$ {* ^3 A
    
36.         },
    / h0 `; h+ a4 r% i- D5 V
37.         op==2 :        //重载运算符*3 ?; x\" R& [; J  m
    
38.         {' s\" I6 |/ p+ }\" c  I: E, Q  T
    
39.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),; U3 h* S# [( }& |- o\" I
    
40.                 i=0, while{i<m,4 w0 M; Z; a. a. q/ @8 C4 h
    
41.                         j=0, while{j<k,
    . G* J$ X; s# f
42.                                 c[i,j]=0.0,7 e8 j9 L# Y) R& B
    
43.                                 u=0, while{u<n,
    % R7 {, a  f- x: j1 B3 O4 o
44.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++* V  P7 d; y  E) a$ V' {7 h# q
    
45.                                 },  u+ |0 |+ i- K: V5 Z3 F- X
    
46.                                 j++
    : v, A8 o; }) b7 g
47.                         },; s1 Y8 m5 @4 z/ L
    
48.                         i++, Z/ Z! C- |( K
    
49.                 },
    + w3 E+ `  o' l
50.                 c& R; }: r+ H2 v
    
51.         },- q3 @3 z: ?4 t
    
52.         op==25 ://重载运算符.*
    / M( w- y6 z6 X. }* t# `% A3 y/ x
53.         {
    / U# X- P5 n2 i* D
54.                 len[x,0,&m,&n], c=new[reals,m,n].global(),  t  v& u$ A2 }
    
55.                 i=0, while{i<m,3 J/ T! o! |- ^! Z$ V
    
56.                         j=0, while{j<n,1 n/ N# ?# L/ }$ n( R' H# O5 T
    
57.                                 c[i,j]=x[i,j]*y[i,j],, j# l5 i\" S$ M\" B% b$ {2 o
    
58.                                 j++
    ( c; D& p4 E/ `2 k' `
59.                         },+ J0 Z8 l; x9 a+ k* r8 Z0 v- b' q7 o
    
60.                         i++
    9 j9 `! J. G1 P7 S% o
61.                 },
    8 U' o4 H) C. `
62.                 c
    5 Y, t\" _. R3 H\" _, ?9 w8 g
63.         },& Y4 f& _: P2 @  Z9 f# q6 j) B' X& o
    
64.         op==26 ://重载运算符./: `* q; g  s: g  [
    
65.         {: @9 n( @0 g9 ^  g
    
66.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    3 U7 r' c# j3 z9 S. y/ @# ?
67.                 i=0, while{i<m,\" N2 C1 @1 `' ~4 \  N
    
68.                         j=0, while{j<n,
    : u% L/ s+ t/ L! ^' ?
69.                                 c[i,j]=x[i,j]/y[i,j],
    6 ]7 E) A; j' Z' q+ v
70.                                 j++/ y9 x8 }$ L& I2 J1 F; G\" c# C
    
71.                         },0 X3 H! i% h, Y% Z+ }\" j- h
    
72.                         i++
    4 {0 V4 }! l' Z8 ~( R* \+ ?
73.                 },
    . B' s% x- \7 ~9 |7 B; B+ p' L
74.                 c* W- h* Q) D6 D  v5 P  l1 f3 h, I
    
75.         },
    8 Z! Q3 @: O4 W$ z% k$ q  I
76.         nil        //该数据类型不支持该运算符的重载，返回nil2 ~) f( M4 W$ I8 W
    
77. };
    2 E( I, r0 L8 P: a( G
78. test(:type,a,b,c)=
    ; w& C; A% S6 H: j6 F, S# I' }
79.         type=mymatrix(0,0,0,-1),  //获取新数据类型9 k& }0 T4 v8 {: U, L\" @0 g  ^& ]$ H
    
80.         a=new[reals,2,3,data: 0.,1.,2.,3.,4.,5.],  //生成矩阵a
    \" Q& i, i& T3 c6 Y
81.         b=new[reals,2,3,data: 1.,2.,3.,4.,5.,6.],  //生成矩阵b  o3 ^9 S0 p4 N
    
82.         c=new[reals,3,2,data: 6.,7.,8.,9.,0.,1.],  //生成矩阵c
    ' ]5 z; X. Y0 B5 H( b& Q* O
83.         o["a="], outm(a), o["b="], outm(b), o["c="], outm(c),  //输出a、b和c
    ) H4 z( E\" b9 S2 N$ E7 V\" m& g4 s
84.         a=cast[a,type], b=cast[b,type],  //强制转换为新数据类型% C9 p3 l/ L' V! D! [6 }
    
85.         o["a+b="], outm[a+b],     //计算并输出a+b
    $ l2 S' J2 P& D5 d8 E0 _
86.         o["a-b="], outm[a-b],     //计算并输出a-b
    / J& d* U: M  q5 a: |4 Z# E6 ?
87.         o["a*c="], outm[a*c],     //计算并输出a*c5 q6 t& a/ L! R4 A
    
88.         o["a.*b="],outm[a.*b],    //计算并输出a.*b
      O# W/ G+ C  x/ v5 o
89.         o["a./b="],outm[a./b];    //计算并输出a./b

复制代码

结果：

1. a=: ^+ C: g8 z: g+ }0 i: }
   
2. 0.  1.  2.    C4 x# j: A. V& ]0 m
   
3. 3.  4.  5.  
   & J& G: ^2 d( q5 l' H) x$ ~5 U
4. b=0 r1 Y) [. j) u
   
5. 1.  2.  3.  * S& p: X  c# \4 H4 H6 v- I
   
6. 4.  5.  6.    l2 @: v  U4 L1 F
   
7. c=
   $ V1 o# |, S+ v8 x4 A0 ^- t
8. 6.  7.  ' N, c) f5 L\" ^4 V$ X
   
9. 8.  9.  3 s' I  N6 D/ D1 T6 i
   
10. 0.  1.  
    5 }- d5 w7 g# ~8 w0 Q
11. a+b=- u! E\" T  S  k
    
12. 1.  3.  5.  
    * t+ U/ k8 p  [$ j) X2 Z; J& }
13. 7.  9.  11.  
    , g2 |) l2 }+ z. h' y+ c6 i
14. a-b=, `+ \$ j* x) p6 R! c% F
    
15. -1.  -1.  -1.  5 J6 Y! W, y) x5 M% w' d( B; P
    
16. -1.  -1.  -1.  1 a3 J, \, M  d$ g
    
17. a*c=) u$ l\" R6 H+ |\" G  q8 C7 d
    
18. 8.  11.  
    % k) }0 w- G8 z9 Q
19. 50.  62.  % {& K3 L( o/ M+ m% [6 u4 Y
    
20. a.*b=  [6 A2 r' l; l; c/ Y1 z
    
21. 0.  2.  6.  . O- z6 G' D8 d; q\" e
    
22. 12.  20.  30.  
    ) M- v7 @$ C\" K
23. a./b=
    . f. K+ [$ b3 o5 V( y- T% K, C
24. 0.  0.5  0.66666666666666663  
    / G& g+ r) X1 o. s2 R; W4 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 //定义矩阵运算
   2 _; j! T! v  K6 c' G
2. {  q\" {* T( f, @- `  f, N
   
3.         op<0  : return[me=newtype()],' K% j/ i0 Q7 h; v7 a/ s( f
   
4.         op==0 : //重载运算符+9 g# s7 H0 d0 V2 z6 T5 I
   
5.         {
   , F+ J; n/ \$ C5 c2 V6 ?
6.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
   $ ?( d( B; l1 X% [
7.                 i=0, while{i<m,
   6 J$ ^) w3 ^0 o7 t\" q' v% e; {- X
8.                         j=0, while{j<n,9 p2 [\" S# c, {% y
   
9.                                 c[i,j]=x[i,j]+y[i,j],
   ( m5 c2 \8 x' G- n- a3 j. e
10.                                 j++6 m7 k$ \. N  n  K  J
    
11.                         },
    $ D$ f) c3 |, Z9 U
12.                         i++0 o0 M& P3 Z/ T* b0 _5 f! n
    
13.                 },/ ^3 X# C8 c+ p; b# @# w! a
    
14.                 cast[c,me]  //强制转换为新类型me（矩阵），下同
    9 {% @3 t* B3 A7 I6 ^+ ]0 [; C  A
15.         },
    0 M6 k3 D* O( b( }! a
16.         op==1 : //重载运算符-% V- k% F) @+ ~, ?
    
17.         {' S& b- r0 Z# `0 h1 J# U
    
18.                 len[x,0,&m,&n], c=new[reals,m,n].global(),' S6 W. l7 \' ]! G% V; N& c& z
    
19.                 i=0, while{i<m,
    - ?$ J$ h1 k( U; E0 i9 }
20.                         j=0, while{j<n,, P3 c$ O6 r$ q' u+ n
    
21.                                 c[i,j]=x[i,j]-y[i,j],2 d/ W% V& y7 b- K* r! G8 l
    
22.                                 j++7 c% b$ o+ l4 l7 s( \! B5 D( U
    
23.                         },\" {! F! }6 l+ C6 j0 r. c* H
    
24.                         i++
    + L' X& }% p; c& n7 E- O& p
25.                 },, ]. P+ ?  _5 e' ^
    
26.                 cast[c,me]; @\" h# r) B( m- o; j  f( a
    
27.         },# A4 l- R0 {9 T3 ]' T
    
28.         op==2 : //重载运算符*
    9 _2 k& O3 `! l, L/ w$ F/ t
29.         {! {0 `! }- l7 d6 s- V! Y
    
30.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),- ~0 G5 |  _2 L5 u0 S\" h
    
31.                 i=0, while{i<m,9 @# Z6 I$ J# s$ Q
    
32.                         j=0, while{j<k,  P6 G  ]$ W) @7 y) R# \6 l
    
33.                                 c[i,j]=0.0,
    % _5 ?2 T  l\" Q. O2 g
34.                                 u=0, while{u<n,
    & a/ E. `2 C+ b8 \5 H. B* }
35.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++
    ; Y4 z* \) }5 @1 A1 v! k3 y0 K
36.                                 },/ a2 b7 x\" V) U, Z+ Q0 _3 B
    
37.                                 j++6 e. c5 Z/ p) Q, `% [
    
38.                         },7 Z+ P: x8 {\" `. [5 y0 \
    
39.                         i++: o9 I0 p: j4 K
    
40.                 },
    + o. V7 ?( [: }6 I$ t! f
41.                 cast[c,me]
    ; W! [' x& N: m; }+ z% h
42.         },: h$ P# \) u7 {9 x* z  l7 ?
    
43.         op==25 ://重载运算符.*# `5 V* C6 O\" F( ?/ ~; O( B8 t2 d
    
44.         {6 U, W\" i' o- X& H  ?' n3 D: J
    
45.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    4 I; S; C' c: w& l1 g/ k* _
46.                 i=0, while{i<m,$ |3 x) w1 j) J# {
    
47.                         j=0, while{j<n,; Y/ O; {* e; Z+ Q! j% h
    
48.                                 c[i,j]=x[i,j]*y[i,j],
    $ f2 B' s. p$ o0 B0 k, g8 l2 s
49.                                 j++
    8 L; d; f0 j9 }7 w- S* a
50.                         },
      n. l+ z5 d  D* }4 S1 o
51.                         i++
    3 L1 [) m7 Q' i9 f1 P. I: _* X
52.                 },
    1 z, J$ v+ G+ p  A5 G2 r$ ]
53.                 cast[c,me]
    / b6 x- t% z3 o
54.         },
    ) F  ]' ~8 ?' _4 K+ ^$ Q3 Z1 {' X
55.         op==26 : //重载运算符./0 A. y8 L- R$ m' c4 y
    
56.         {8 T7 N! ^' ^% {% n, W$ I
    
57.                 len[x,0,&m,&n], c=new[reals,m,n].global(),1 z. s9 K& N3 g) |6 j
    
58.                 i=0, while{i<m,0 M! R/ w4 |' I& i- i
    
59.                         j=0, while{j<n,% v8 U$ @1 h\" j4 y2 d$ n& Z$ i3 F
    
60.                                 c[i,j]=x[i,j]/y[i,j],' o3 R' Z! m\" Q\" I2 h
    
61.                                 j++
    ' i\" g. x0 U5 `2 V5 g8 p4 e8 H
62.                         },% N1 c/ d$ R7 p4 l! M/ Q1 l
    
63.                         i++/ F( k8 \' \3 b\" L% K0 R
    
64.                 },; F) l\" j% W) [. t8 @0 T5 t8 ]6 q7 J
    
65.                 cast[c,me]
    2 Z$ Z/ i) U% h) b% \$ J. |0 Q
66.         },; w5 f5 w4 _5 s! K- t
    
67.         op==46 : //重载函数new
    ; S  ?* C% {3 Z' ]* s
68.         {
    $ @% X# F1 c0 s8 ?5 d
69.                 c=new[reals,y,z].global(), m=len[para], k=0,
    7 _+ c, \) c1 Z
70.                 i=0, while{i<y,$ T% N% b# A7 Y* J0 w
    
71.                         j=0, while{j<z, if{k>=m, return[cast(c,me)]}, c(i,j)=para[k++], j++},
    5 d1 i6 I' t\" n2 |2 O- p7 y
72.                         i++, W; s( a! T9 a! g& w. x) S; }% O1 C
    
73.                 },% T. N9 Y1 o' H1 H, J+ C+ l8 I2 N* m
    
74.                 cast[c,me]3 a: B0 g8 o$ O& e; ?
    
75.         },( d1 o- p$ i% A
    
76.         op==49 : //重载函数o6 X; k4 @5 b1 B' [9 Y8 [
    
77.         {4 v  _  E+ j: m- v/ N
    
78.                 len[x,0,&m,&n], k=0,
    6 _\" a0 U4 G# c% f
79.                 i=0, while{i<m,
      u' h6 `: ~: d* R
80.                         o["\r\n"], k=k+2, j=0, while{j<n, k=k+o[x(i,j),"  "], j++},  Z\" A, _* w3 u9 b
    
81.                         i++4 I0 r2 `: ?4 L6 F& V9 U
    
82.                 },: f) ~& i2 Y  G( H) |
    
83.                 o["\r\n"], k+2
    8 {& J2 p0 s. D: e6 J! {
84.         },0 l8 n2 {* u( x0 t& ^0 H1 m
    
85.         nil     //该数据类型不支持该运算符的重载，返回nil
    6 g. Z9 i2 m8 F0 @5 V
86. };- {4 n4 f6 u9 e: H
    
87. test(:type,a,b,c)=
    ! z& r( @5 x$ t% G5 c
88.         type=mymatrix(0,0,0,0,0,-1),  //获取新数据类型3 V. i4 s2 M9 g, @
    
89.         a=new[type,2,3,lu[0.,1.,2.,3.,4.,5.]],  //生成矩阵a, L9 h' [9 }# w& f. X
    
90.         b=new[type,2,3,lu[1.,2.,3.,4.,5.,6.]],  //生成矩阵b5 S* |- L; w8 ^
    
91.         c=new[type,3,2,lu[6.,7.,8.,9.,0.,1.]],  //生成矩阵c\" {; f% P& l0 P& |
    
92.         o["a=",a, "b=", b, "c=", c],  //输出a、b和c
    7 x# C- B  b\" b
93.         o["a+b=", a+b],     //计算并输出a+b
    , m. o\" k0 f/ p; Q
94.         o["a-b=", a-b],     //计算并输出a-b% b8 w1 ~0 |0 t. S
    
95.         o["a*c=", a*c],     //计算并输出a*c
    1 I4 S/ t0 T( K) h( |+ ]
96.         o["a.*b=",a.*b],    //计算并输出a.*b
    5 g7 P) L4 _6 P, ]3 f' v# l0 B
97.         o["a./b=",a./b];    //计算并输出a./b

复制代码

结果：

1. a=
   $ v& r9 \& @: ?; E' Y) }( n
2. 0.  1.  2.  
     p  }9 x* J. m9 J5 y! ^& K
3. 3.  4.  5.  ; o2 R) S2 I8 W) D
   
4. b=& h8 d& l( x' U4 V' i  t& G
   
5. 1.  2.  3.  6 O\" i6 A; b: d# E4 E) ~
   
6. 4.  5.  6.  
   4 T  y) o4 y\" ]  J( K7 l
7. c=  w$ T+ j\" T& J( D8 S! T
   
8. 6.  7.  0 c; h/ O' w, R+ ~' ?\" w. y% P' W
   
9. 8.  9.  
   7 v, j\" P. d- S
10. 0.  1.  
    6 t6 {/ Z/ h. d1 e- S  ]4 {
11. a+b=; d. z9 r# q0 t6 g
    
12. 1.  3.  5.  ' ]0 \8 k7 ^6 U9 ?% Z/ n( F8 T6 L
    
13. 7.  9.  11.  
    $ ^3 u0 Y. p8 W5 t) ~  `7 [! u
14. a-b=
    5 ^7 ?/ D; u' y. x
15. -1.  -1.  -1.  
    & x3 o, p' c: V, l0 c8 [1 w
16. -1.  -1.  -1.  
    - M8 J1 b0 R  `; @/ g
17. a*c=( a$ ?\" z9 v7 h7 z
    
18. 8.  11.  
    2 u. F- M- K0 d\" [+ K4 e
19. 50.  62.  ( k% s) C. R$ p* f\" t( Y* w) F
    
20. a.*b=
    ' w; W0 ~) P. L: W, d
21. 0.  2.  6.  
    0 T+ B; N& y! X: E% U4 o
22. 12.  20.  30.  - Z2 l. U  s$ j6 J8 t$ n
    
23. a./b=( K# i5 B% f8 h. n, m- {* o
    
24. 0.  0.5  0.66666666666666663  
    4 k' r7 C- G# @6 _
25. 0.75  0.80000000000000004  0.83333333333333337  

复制代码

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

www.tgchaye.com

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