Lu中的运算符重载

forcal

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

1. thetype(x,y,num,op)=which
   # T4 ~! M. H/ m- R% y* x  u
2. {/ k7 B+ c- J\" f
   
3.   op<0  : return[newtype()],  c4 O, i+ Q8 A4 n1 f$ V
   
4.   op==0 : x-y,    //重载运算符+  ~# M& A- x; B+ z
   
5.   op==1 : x+y,    //重载运算符-5 \( `2 B/ x: I+ Q4 Z$ Y
   
6.   op==2 : x/y,    //重载运算符*
   7 M% Z6 f: u% ~1 I* a
7.   nil             //该数据类型不支持该运算符的重载，返回nil4 z6 B; `2 P  m& R
   
8. };
   , M' P! u5 f4 r! s, _
9. test(:type,a,b)=' p6 b7 y4 o% _& L
   
10.   type=thetype(0,0,0,-1),  //获取新数据类型
      u  b% {! I7 I6 ]4 N1 N
11.   a=cast[3,type], b=cast[5,type],  //强制转换为新数据类型
    : ]; {4 D* r( w* }0 _
12.   o[" a=",3," b=",5],  //输出a和b( y0 z4 `- h3 Z; c
    
13.   o[" a+b=",a+b],      //计算并输出a+b，变成了a-b
    / ]2 G1 b1 z# r3 {
14.   o[" a-b=",a-b],      //计算并输出a-b，变成了a+b
    5 T- ^( ?7 n$ [1 o\" H& Y
15.   o[" a$b=",a$b];      //没有重载运算符$，故输出nil

复制代码

结果：

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

复制代码

＝＝＝＝＝＝
) J4 L' W8 A. `5 R+ D9 e( J
8 M1 e# x) ]+ E' j0 d* ]  Lu核心库中没有提供矩阵运算，但在脚本中可以通过重载运算符来实现：

1. outm(x:i,j,m,n)= //输出一个矩阵
   ! b8 u) f* N! L. w) M  M$ p% {2 c. F
2. {
   : g4 ^, ~& P7 ^1 D' m. ?
3.         len[x,0,&m,&n],2 q8 |\" X' P# d\" E! e4 B4 d
   
4.         i=0, while{i<m,
   / y/ }' p5 W. W! E( Z& |
5.                 o["\r\n"], j=0, while{j<n, o[x(i,j),"  "], j++},- F2 W; D  Y( A; p  d' @\" U! g
   
6.                 i++
   : R' x+ ]% R8 c# ~' o' e/ M
7.         },
   . {3 T\" G: x3 |5 ^
8.         o["\r\n"], x! G' }* ^% Y  o5 z- B% l
   
9. };
   6 |5 K. e  n\" ]
10. mymatrix(x,y,num,op:c,i,j,k,m,n,u)=which //定义矩阵运算& N+ w: P; b* u! b7 q; Q3 C$ l
    
11. {\" _% j: ]* j2 i2 r
    
12.         op<0  : return[newtype()],
    & v5 v7 e! T: S0 U; K
13.         op==0 :        //重载运算符+
    0 R* `) C/ {# B\" u% ~4 Z
14.         {
    ! q3 c\" F\" I( V3 |. D
15.                 len[x,0,&m,&n], c=new[reals,m,n].global(),: I9 i! Y% c' t, s, I) X
    
16.                 i=0, while{i<m,/ R3 ~4 i2 N! ?# Y; y: q
    
17.                         j=0, while{j<n,
    2 t! \% p2 J1 }6 I& s\" D& p
18.                                 c[i,j]=x[i,j]+y[i,j],8 e- O- S' W9 v; y$ A5 K/ y
    
19.                                 j++; k\" ^7 j2 l& |/ V; G0 {
    
20.                         },3 M5 ~\" |/ L* c7 y! O5 h7 K: o
    
21.                         i++! F4 x* S1 k8 p: V
    
22.                 },7 u, V+ G2 }  I: E  g, h
    
23.                 c( x\" M; T% m  P! J
    
24.         },
    ( s# S  E\" V$ I  H; z
25.         op==1 :        //重载运算符-
    2 |  L7 G9 V6 q\" x\" |
26.         {. e6 n' q/ K! A; n1 C/ g\" {/ P+ F
    
27.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    3 y. Q& s: y\" s
28.                 i=0, while{i<m,0 f, `% R0 d: K% H  C
    
29.                         j=0, while{j<n,
    \" F# ~  N3 j* r% b- ^5 ?9 _
30.                                 c[i,j]=x[i,j]-y[i,j],
    ' X/ T* R2 Y) Z% n9 R
31.                                 j++
    : q6 A- G2 r( t* x9 |) H: z\" n
32.                         },
    \" z; j3 T* Z1 R0 Q+ ^( H\" Q
33.                         i++
    6 ^1 ?' b+ X- Y: M& ]6 u5 P8 s% r
34.                 },
    : u; N' {& F/ G: b
35.                 c
    : I1 d. A\" U5 O) e
36.         },  J/ q* K4 ]& M- m6 X
    
37.         op==2 :        //重载运算符*! u0 l% p& b( Y6 I8 `, n
    
38.         {, [\" G; X8 s3 M$ f, ]
    
39.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),' y0 t& ?* b, C% t4 I. q\" Q
    
40.                 i=0, while{i<m,: |. A8 v/ [: s# P: @, {% y
    
41.                         j=0, while{j<k,; a# c3 f! {, C1 M0 z& g
    
42.                                 c[i,j]=0.0,
    ) B- |\" o, W! c# r* N% d  I- \' S5 ?
43.                                 u=0, while{u<n,
    * \) N7 S( V6 c, s8 X
44.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++
    3 R( B% N0 A4 E* _9 U' J8 H) G
45.                                 },
    8 {. ], D4 T( O- C- e
46.                                 j++; B8 L: G: X! w  h2 h3 v/ n
    
47.                         },/ s. A/ A7 T. e, d5 ]/ q
    
48.                         i++
      n  U% d. Y0 b9 G& A4 l3 r
49.                 },
    % c5 j% t0 J+ s\" O, G
50.                 c8 W! {( K# m# T$ M9 f; b3 K, m\" S  E
    
51.         },9 E! w9 z, O0 s) M9 F
    
52.         op==25 ://重载运算符.*6 J0 V7 W, e( r
    
53.         {
    5 A+ z' _9 c% s+ _/ g% M
54.                 len[x,0,&m,&n], c=new[reals,m,n].global(),7 c: L3 v3 \  a6 R
    
55.                 i=0, while{i<m,
    & U% s' ]  v2 q6 E4 q
56.                         j=0, while{j<n,6 u3 `+ z3 _: }* ~( _
    
57.                                 c[i,j]=x[i,j]*y[i,j],4 ]9 V  P$ E1 a\" z
    
58.                                 j++4 W  j/ H! s4 x\" d
    
59.                         },
    6 Y. p6 D' \1 D( o% Z
60.                         i++
    - v4 @4 j) M% A8 ~  X4 ^1 E
61.                 },4 Q, N0 I9 T1 E3 N& d# h
    
62.                 c5 U* Q3 @4 U( k% H8 v9 |6 U+ i
    
63.         },- F) x) _  b7 N0 o( N! r
    
64.         op==26 ://重载运算符./
    7 Q0 C. q9 g% |' c( _. G, S3 E
65.         {
    8 M( u/ M2 q3 J0 ^: h2 _
66.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    3 I* n. K% l; f% H$ c7 E
67.                 i=0, while{i<m,
    \" S% ^0 B$ N' g2 z% m: ^9 l% B
68.                         j=0, while{j<n,0 n7 u% N$ [: [8 _- ?
    
69.                                 c[i,j]=x[i,j]/y[i,j],- }7 M0 z8 g* I$ C$ |7 T
    
70.                                 j++
    ; ], m5 s8 r7 N% V# O- F
71.                         },
    5 M. s- V7 [; w\" ^# x4 W* `$ p
72.                         i++
    , Z* L* N% l) x
73.                 },
    ! t( B6 |& V7 t6 y
74.                 c  B7 s' x$ |% D/ u
    
75.         },% w( I; C  t$ [
    
76.         nil        //该数据类型不支持该运算符的重载，返回nil
    / G& {4 }\" ~1 `5 j# }; q
77. };  b) ^5 N4 E6 z2 e; M; L
    
78. test(:type,a,b,c)=
    7 O/ q. r  u4 k0 H\" h+ X
79.         type=mymatrix(0,0,0,-1),  //获取新数据类型
    $ F1 A7 Y$ ]$ r, b$ P- N
80.         a=new[reals,2,3,data: 0.,1.,2.,3.,4.,5.],  //生成矩阵a
    0 {0 \2 q: K, g: \' a$ d- O5 x- r
81.         b=new[reals,2,3,data: 1.,2.,3.,4.,5.,6.],  //生成矩阵b
    9 Q: J1 d$ v# B0 W& p. m5 |! C0 k  X
82.         c=new[reals,3,2,data: 6.,7.,8.,9.,0.,1.],  //生成矩阵c
    ! x, A/ W' @3 E6 j6 D% d$ y, K
83.         o["a="], outm(a), o["b="], outm(b), o["c="], outm(c),  //输出a、b和c
    + Y4 ~7 k0 v: U8 A% D
84.         a=cast[a,type], b=cast[b,type],  //强制转换为新数据类型
    ! h( O/ s$ l7 J( H
85.         o["a+b="], outm[a+b],     //计算并输出a+b
    ' C8 q# o% s9 O
86.         o["a-b="], outm[a-b],     //计算并输出a-b! F/ D* C& e: T, y6 r, \
    
87.         o["a*c="], outm[a*c],     //计算并输出a*c
    8 Y) n% {  E+ D7 o1 A
88.         o["a.*b="],outm[a.*b],    //计算并输出a.*b0 H4 U8 h2 y, e( R3 ^( a9 a
    
89.         o["a./b="],outm[a./b];    //计算并输出a./b

复制代码

结果：

1. a=
   : j+ W0 H) U/ E4 H
2. 0.  1.  2.  4 ]1 V5 L. t& _4 A) X1 N
   
3. 3.  4.  5.  & \6 Y; L6 M) \) i) f# u6 Z) f+ w
   
4. b=! e+ I5 S7 P' h, @0 p9 g' T2 g
   
5. 1.  2.  3.  ; [* G8 y6 h; ^
   
6. 4.  5.  6.  $ Q) P: n9 a7 |$ g5 S
   
7. c=
   , n; ]1 p9 v. W, ^1 F9 r* ?: ^
8. 6.  7.    c! b/ p$ j! ~3 |8 K2 f8 d/ f
   
9. 8.  9.  ) y. a3 P! {/ x2 |1 ^
   
10. 0.  1.  
      X' y( C# m. h4 c% |% h
11. a+b=
    ! f- U, |0 c7 y# f
12. 1.  3.  5.  
    ; S( A! f+ X$ P$ a
13. 7.  9.  11.  . U* L/ h: z/ u+ J
    
14. a-b=
    * D, t3 O' F; d2 n( z2 u  I
15. -1.  -1.  -1.  5 K* Q8 ]0 S4 |  a% }
    
16. -1.  -1.  -1.  
    # ^# e; P0 j) y
17. a*c=
    1 L7 o) o: ]: s1 O
18. 8.  11.  
    8 r  x/ A) H, e( ?! X! s) Q
19. 50.  62.  7 q' b' W- f; c! e& j
    
20. a.*b=6 l7 u- h3 F$ E: G2 `8 O
    
21. 0.  2.  6.  
    / y, _3 s0 ^, }7 F
22. 12.  20.  30.  # S; X# e. {8 M4 U4 P; h$ N
    
23. a./b=
    $ w9 ?' V9 U4 V5 \; }
24. 0.  0.5  0.66666666666666663  $ N8 r# T  N4 B0 _( I- C( A$ R! R+ q
    
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 //定义矩阵运算
     I& @8 _  G& T7 S# }- u& h& B; w\" T
2. {
   $ m, J8 y$ T* T# x. J$ j. |$ ]
3.         op<0  : return[me=newtype()],
   2 w6 N9 ^+ r- S& i9 \2 }4 ?
4.         op==0 : //重载运算符+
   4 P1 K! u% [, }  r
5.         {& `. G  f! l0 \\" e1 ]
   
6.                 len[x,0,&m,&n], c=new[reals,m,n].global(),# `$ J' N& w# [  z' _( M# T
   
7.                 i=0, while{i<m,# M4 _* L9 _/ A/ S\" F. j  i
   
8.                         j=0, while{j<n,
   - N/ h, T5 f5 q3 _, _
9.                                 c[i,j]=x[i,j]+y[i,j],8 J3 K3 ~* W9 \; m5 Z9 l
   
10.                                 j++6 j\" s5 v( L3 m8 q: {
    
11.                         },
    6 x! O1 x: C1 Z; l2 ^% u: S
12.                         i++
    % E$ Z3 m9 ]# c2 ~% Y& d$ i' F
13.                 },
    , S4 ?: |0 J7 _  j  o! r
14.                 cast[c,me]  //强制转换为新类型me（矩阵），下同, O5 d) t\" f5 Y- y% P
    
15.         },
      L\" Q, J# C! m/ S5 M7 k- C
16.         op==1 : //重载运算符-
    . Y3 w; |% h  ?
17.         {: h% K4 W4 p. S
    
18.                 len[x,0,&m,&n], c=new[reals,m,n].global(),! Q) F\" C6 D' b4 y, R( z/ m' D
    
19.                 i=0, while{i<m,
    \" t- J# `7 {. P7 J) N
20.                         j=0, while{j<n,5 w# |. w7 u  |& \. M5 b) t0 W5 i( x
    
21.                                 c[i,j]=x[i,j]-y[i,j],/ ]: c3 a4 a% X2 L; j
    
22.                                 j++# f\" @8 @3 N9 J* k\" S( H
    
23.                         },
    9 W, Y% A+ `! c# j
24.                         i++3 |8 n8 L* o6 @& C$ v
    
25.                 },
    / `3 U( k6 N. l' I5 d9 o
26.                 cast[c,me]
    ! k: w, c$ A& l1 _3 M- \
27.         },8 A, _/ s+ j+ J8 `2 A( y6 x
    
28.         op==2 : //重载运算符*; l. B3 {/ e  _2 x3 G: q; T2 V
    
29.         {
    7 ~# k5 {; W/ X. m* S% a
30.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),
    8 e) ?6 T; J2 z$ n, i5 H
31.                 i=0, while{i<m,
    \" i0 ]/ ?. _+ a1 l0 m1 I\" m
32.                         j=0, while{j<k,
    5 Z+ Z\" e, X; R, D2 V% \& I
33.                                 c[i,j]=0.0,6 W$ x3 A( U3 C3 I8 `6 ?
    
34.                                 u=0, while{u<n,
    * }/ O; a# b' a% _; z& T6 D, w
35.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++3 P* b1 ~- E% M3 V) p
    
36.                                 },8 n3 i( r6 _$ S) ^  J
    
37.                                 j++9 D& S4 b5 p2 V& c- B. M\" [& I
    
38.                         },: p5 D# f7 Y- e
    
39.                         i++( c* ~0 I+ y3 O/ V5 |7 S; V  ~
    
40.                 },
    / d# c; N0 k& R$ x\" Q  E; B: f
41.                 cast[c,me]
    + a% Q3 F% H) s1 x
42.         },& t$ d$ {) v4 p, X
    
43.         op==25 ://重载运算符.*! v7 u) }4 |, E% I
    
44.         {
    # D, y\" M4 x& w0 @
45.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ( `7 i+ [9 P  u* R9 Z( D% E' k3 w
46.                 i=0, while{i<m,
    . z( ^5 W4 d- N& D6 v8 u- ~\" T7 h
47.                         j=0, while{j<n,
    6 g( [. O\" M3 J
48.                                 c[i,j]=x[i,j]*y[i,j],
    3 j. A) J3 {: F) Z6 U7 D
49.                                 j++  w9 w0 l\" S2 x8 u  `% h
    
50.                         },' w4 K; U8 ^6 G) F4 D4 P+ q
    
51.                         i++  ?5 C: Q& m6 f, x& R6 y. @, {' [
    
52.                 },1 r7 _( q: ]8 i, X# {- U; U% N2 }
    
53.                 cast[c,me]1 N! |, V+ F1 l/ Y1 J
    
54.         },5 t+ |- B1 z2 j\" B/ `# i/ m
    
55.         op==26 : //重载运算符./
    . G- K! ]- v# A1 D
56.         {) l4 c0 k, R$ f2 d
    
57.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ' x- v% F( O$ y9 G
58.                 i=0, while{i<m,0 f/ f6 {4 [1 }9 t/ U
    
59.                         j=0, while{j<n,3 \  ]) C2 ^; n* R  F5 m
    
60.                                 c[i,j]=x[i,j]/y[i,j],9 T+ y7 A1 @6 m, @$ C) C# B3 Z\" N) b
    
61.                                 j++, [7 C+ X& k3 ?% k4 J' k
    
62.                         },* z4 g  o3 o- D( h
    
63.                         i++
    4 B4 q! M% W6 j; H6 W- Y
64.                 },
    ! q) P2 f6 a/ t
65.                 cast[c,me]
    1 f4 @+ {: W7 b: S8 r' K* O
66.         },& \6 n0 O$ b! _0 E
    
67.         op==46 : //重载函数new
    - T6 p, q4 K! z# A, D4 d4 k
68.         {2 P, Q( Q% c0 k) t) o# x\" r
    
69.                 c=new[reals,y,z].global(), m=len[para], k=0,  t7 ?8 I6 n9 r3 [4 }: ^5 D
    
70.                 i=0, while{i<y,
    5 l( M  K; k0 G! H, V
71.                         j=0, while{j<z, if{k>=m, return[cast(c,me)]}, c(i,j)=para[k++], j++},
    0 L, w4 A% |0 @- l) S/ n' L# X- B
72.                         i++' ~! g+ p8 w' |1 [! }
    
73.                 },/ z# J9 _% I1 H3 J1 n, \3 `/ Q
    
74.                 cast[c,me]8 c. K\" m6 m1 W# O# u
    
75.         },
    ! w/ F* L% o1 j\" q
76.         op==49 : //重载函数o# @. T1 c& q: Z3 t3 r3 S/ }! y$ n
    
77.         {
    1 V3 o8 b8 {\" @/ W4 D
78.                 len[x,0,&m,&n], k=0,
    \" W# t/ Z: B% g9 x2 j$ v
79.                 i=0, while{i<m,$ n' k8 Q  m6 D) g* U( {( i$ L
    
80.                         o["\r\n"], k=k+2, j=0, while{j<n, k=k+o[x(i,j),"  "], j++},! A0 ]/ Q; v+ R+ d
    
81.                         i++* u5 p2 H7 K5 i0 m; Q; w+ _
    
82.                 },
    ) U7 w- z2 _! p# p
83.                 o["\r\n"], k+2- T0 [% o; q9 G
    
84.         },0 A, m- v) T5 g
    
85.         nil     //该数据类型不支持该运算符的重载，返回nil
    , |0 \& v; D4 X2 ?# D& m
86. };
    , Q% u1 R0 H) a5 S! d
87. test(:type,a,b,c)=
    * u# D: l6 K7 V6 K8 h6 N/ L; G+ O+ N1 D- `
88.         type=mymatrix(0,0,0,0,0,-1),  //获取新数据类型+ A! `+ W& h4 M+ F/ m; S
    
89.         a=new[type,2,3,lu[0.,1.,2.,3.,4.,5.]],  //生成矩阵a
    2 p6 W- N. l) l
90.         b=new[type,2,3,lu[1.,2.,3.,4.,5.,6.]],  //生成矩阵b
    \" B) P) C5 ~: `0 R/ P: g5 ~  r
91.         c=new[type,3,2,lu[6.,7.,8.,9.,0.,1.]],  //生成矩阵c
    - {2 ?7 x\" k$ R7 B  T
92.         o["a=",a, "b=", b, "c=", c],  //输出a、b和c, M8 i. C. ?  q1 ~\" Y# ~
    
93.         o["a+b=", a+b],     //计算并输出a+b
    6 K' E5 Z7 m0 y3 ^% v
94.         o["a-b=", a-b],     //计算并输出a-b
    - M9 b* V$ _8 o  r- _( R& r
95.         o["a*c=", a*c],     //计算并输出a*c
    ) [! r/ z+ ]/ {; p
96.         o["a.*b=",a.*b],    //计算并输出a.*b! O6 ?7 ]* E& W, o2 v, A# O
    
97.         o["a./b=",a./b];    //计算并输出a./b

复制代码

结果：

1. a=! y: K( F' D3 x! L. c% ]) W! A
   
2. 0.  1.  2.  , R6 X  }3 X' t- P4 T
   
3. 3.  4.  5.  
   9 Q# b7 y  r' g* }2 l/ ?7 s
4. b=2 H8 Y2 ?, ]3 u: i5 h5 i
   
5. 1.  2.  3.  ! _3 n  x3 s: Q# y: Z
   
6. 4.  5.  6.  
   \" x9 K; A5 O7 B
7. c=
   6 C9 `1 I) c0 A  B7 ^. d% Z
8. 6.  7.  
   3 M) U  O. ]# P$ X: k9 c
9. 8.  9.  ! h0 c: E' c, F6 U: X4 k
   
10. 0.  1.  
    + P( _6 C/ r7 K4 C* |4 S
11. a+b=4 W2 P3 a. f\" c6 y. O
    
12. 1.  3.  5.  ! r! P' I# C  y' O, w' Z
    
13. 7.  9.  11.  & }  ~1 t- h4 W5 @9 E# W9 B5 _
    
14. a-b=; S- j; |; z& a; d: U
    
15. -1.  -1.  -1.  ( }8 }$ l\" _4 _  X/ h  a
    
16. -1.  -1.  -1.  
    3 P2 N3 x. Z; v2 V) T5 ?
17. a*c=
    \" V' Q) G5 j8 |\" y6 G
18. 8.  11.  / |0 @5 K\" |2 v- a
    
19. 50.  62.  
    ' d3 u# w2 D% v: n2 y, H+ Q$ S
20. a.*b=
    \" u6 q$ p, r+ u6 n1 r
21. 0.  2.  6.  
    & ~/ }) ?* k, V3 f0 c! y
22. 12.  20.  30.  
    ) I, e+ N& Y; Y. l
23. a./b=! N  A, {4 W* b6 i3 |
    
24. 0.  0.5  0.66666666666666663  
    ) g4 w$ V; N/ ~2 m/ d4 u+ C
25. 0.75  0.80000000000000004  0.83333333333333337  

复制代码

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

www.tgchaye.com

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