Lu中的运算符重载

forcal

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

1. thetype(x,y,num,op)=which5 S2 s6 l1 I: S  }0 [
   
2. {' k) g9 J+ [# o& ?- j4 s
   
3.   op<0  : return[newtype()],
   % M  Q1 u; o- S% h! m
4.   op==0 : x-y,    //重载运算符+
   , l- `  M& D9 i+ i8 t: [
5.   op==1 : x+y,    //重载运算符-
   * R! L! z( U5 |4 U, J: ?
6.   op==2 : x/y,    //重载运算符*
   9 c2 |- _, j\" S: x& u2 n
7.   nil             //该数据类型不支持该运算符的重载，返回nil
   6 C! |8 Z* v( p: K
8. };$ d5 K, Y! ]- w( e* B. d# X
   
9. test(:type,a,b)=
   ( w# @# d: I6 J- i0 \
10.   type=thetype(0,0,0,-1),  //获取新数据类型
    8 d3 d! p\" T  Z. C/ K6 l
11.   a=cast[3,type], b=cast[5,type],  //强制转换为新数据类型- X  k5 J( n+ a. h# [
    
12.   o[" a=",3," b=",5],  //输出a和b
    ; k1 ?! [* n& k- T) [
13.   o[" a+b=",a+b],      //计算并输出a+b，变成了a-b
    1 i! L( X+ Y: O. l, u: t0 m
14.   o[" a-b=",a-b],      //计算并输出a-b，变成了a+b
    ' `3 p( e5 c5 w( ^
15.   o[" a$b=",a$b];      //没有重载运算符$，故输出nil

复制代码

结果：

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

复制代码

＝＝＝＝＝＝
" W' ~8 `& y  q' S& X0 @5 f+ n
  Lu核心库中没有提供矩阵运算，但在脚本中可以通过重载运算符来实现：

1. outm(x:i,j,m,n)= //输出一个矩阵, J7 i4 q/ j! c+ P' {; `
   
2. {
   * W/ }2 g$ O/ ?+ z+ b, {
3.         len[x,0,&m,&n],
   0 @! R- q- K+ \\" ]3 g) K6 t
4.         i=0, while{i<m,  M( j9 C& A$ S2 i+ |% [
   
5.                 o["\r\n"], j=0, while{j<n, o[x(i,j),"  "], j++},6 \! p+ ~4 v/ ~
   
6.                 i++
   3 B! G; E/ G: k; ^1 l
7.         },
   1 Z6 o\" `* j+ D; c\" N7 Z
8.         o["\r\n"], x
   * r7 Q7 }: ]( {+ X7 C$ P9 E, H
9. };9 @+ Z* \& ~- u\" g2 T3 M
   
10. mymatrix(x,y,num,op:c,i,j,k,m,n,u)=which //定义矩阵运算! l6 _6 e9 u; u* Z% A/ X( Q) H+ X
    
11. {
    + }5 C% U/ p1 {
12.         op<0  : return[newtype()],9 v$ @: D/ C. P# f& S1 m6 ?
    
13.         op==0 :        //重载运算符+* x\" k  E8 ]3 E4 ^
    
14.         {
    # K( v$ ?1 p. z2 y( E, z8 l. }$ \
15.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    8 ]8 j/ g& n9 {% r! Z! c
16.                 i=0, while{i<m,+ p/ M7 O  [1 q
    
17.                         j=0, while{j<n,9 @. u- }\" q/ k  @6 y  G
    
18.                                 c[i,j]=x[i,j]+y[i,j],: S  m; b- R2 i/ s
    
19.                                 j++6 O6 I' F4 o$ r1 v+ w
    
20.                         },3 y2 ?# P0 e+ F& W3 v* Y4 l
    
21.                         i++
    , o( E7 U* M# ?2 W\" A6 I
22.                 },
    4 V3 m, e5 l5 F' U, H
23.                 c
    6 I9 E8 E% s- m2 w. ?2 d. A- @
24.         },* I\" l3 P4 }# f6 `6 L$ D
    
25.         op==1 :        //重载运算符-
    6 y! B9 P! h! J# m  h- t6 b) d. p
26.         {' V9 X1 G1 a7 z  g1 n. m# J8 L3 @
    
27.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    9 F+ C# U+ {; _: ^; A3 r% K3 A
28.                 i=0, while{i<m,  q& \- H' G6 j1 ^% r) q
    
29.                         j=0, while{j<n,
    ' d( A5 q5 k0 p1 l
30.                                 c[i,j]=x[i,j]-y[i,j],/ ?7 Y8 S: f0 H8 z
    
31.                                 j++
    ' w% }\" j' X! c1 Y
32.                         },( U+ e9 j9 k  U, ?! N8 }\" L0 O
    
33.                         i++
    : t3 n3 N5 c8 }& u
34.                 },
    0 i3 a0 H2 i' {- t! O9 ]/ C8 K
35.                 c
    7 M/ x! v0 p- o7 c& H- |& K
36.         },
    ! g% r* w: x+ h
37.         op==2 :        //重载运算符*
    & a; C/ v, |! I' r' m7 U! B1 T
38.         {
    6 D% o& m8 s5 R0 _\" s5 x
39.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),7 k+ D9 A; m6 n- _5 \- ~0 X
    
40.                 i=0, while{i<m,1 L3 K7 d( l\" J2 V% L% @1 f8 r
    
41.                         j=0, while{j<k,
    - P$ J1 l5 Y5 }+ }& p# C$ S
42.                                 c[i,j]=0.0,5 w. Q) G' `2 {, k
    
43.                                 u=0, while{u<n,
    & `/ ]8 K1 n, p& {0 e
44.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++8 d% q; M( ^* K3 k. Z4 o* @6 k
    
45.                                 },
    ! y+ Y5 ^, |& [; ^% f  o7 j( ]$ B
46.                                 j++
    & V4 U\" \$ K5 Y, T/ K
47.                         },* t1 O; N0 Y$ {; d7 F' S
    
48.                         i++. c( b; J/ ^\" R1 S6 r\" G# R8 j4 Z
    
49.                 },
    : Z  x; I! x, R5 p
50.                 c% `1 w\" h2 R  D: {9 l# @. F
    
51.         },5 L# f\" P8 {: `. x4 d: \0 I6 h
    
52.         op==25 ://重载运算符.*% Y$ C\" A1 w+ O
    
53.         {
    - z* P: ?- I6 Z$ o# o$ o
54.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    ; \3 l1 d8 C; A
55.                 i=0, while{i<m,
      q* m# X\" H) G\" i# r+ V
56.                         j=0, while{j<n,2 C1 i\" p1 `: E$ T$ z6 s! I
    
57.                                 c[i,j]=x[i,j]*y[i,j],
    ( H: @5 x  f, n$ Z
58.                                 j++- I- T- k) X! z' E
    
59.                         },
    * Z9 `* G% d! e
60.                         i++
    6 Y\" D/ J* L8 N$ D& p6 w. ?+ ^
61.                 },2 O# R6 f8 G) {\" T( {5 @
    
62.                 c- G5 Z# R# K/ b: T- z
    
63.         },' E\" E) g- [' x9 O. x& y$ a
    
64.         op==26 ://重载运算符./  J- X2 H2 f! O3 y- e- k
    
65.         {
    $ [& c: Y( \- q
66.                 len[x,0,&m,&n], c=new[reals,m,n].global(),$ J) }& k! r7 M4 p# Y( l; `
    
67.                 i=0, while{i<m,4 J0 ]+ ]4 ?/ W* g7 s, Z- T& n5 j
    
68.                         j=0, while{j<n,; W* V3 F) k$ r. |1 m3 `; R. |& O
    
69.                                 c[i,j]=x[i,j]/y[i,j],$ o6 ?' z# M  D: q1 l2 s3 V
    
70.                                 j++& S3 e% S- I& n
    
71.                         },7 [\" w6 k% B8 r- t3 A
    
72.                         i++
    6 b* N# ]' Y2 v* F  U
73.                 },$ d. `# D9 M1 ~) m( m% [
    
74.                 c! h! O( ?8 z- w* _; y& z# o! M
    
75.         },) Z/ b% k4 `0 Y4 W
    
76.         nil        //该数据类型不支持该运算符的重载，返回nil
    3 o4 j: ~* I( u2 D8 ?7 h% b
77. };
    . X+ ]$ D4 A3 g% l- [% I+ Q# W3 k
78. test(:type,a,b,c)=
    / c8 k7 O- u/ }6 p3 E- W
79.         type=mymatrix(0,0,0,-1),  //获取新数据类型
    ' C; C/ K, L7 v( s0 @
80.         a=new[reals,2,3,data: 0.,1.,2.,3.,4.,5.],  //生成矩阵a/ r$ o3 Q7 _) I: y% P
    
81.         b=new[reals,2,3,data: 1.,2.,3.,4.,5.,6.],  //生成矩阵b$ U  K/ E. y) a
    
82.         c=new[reals,3,2,data: 6.,7.,8.,9.,0.,1.],  //生成矩阵c
    . o& m) W- m) [7 Y  H' [+ h4 q6 V
83.         o["a="], outm(a), o["b="], outm(b), o["c="], outm(c),  //输出a、b和c. j5 Q+ ?- X9 l7 D1 K3 Z
    
84.         a=cast[a,type], b=cast[b,type],  //强制转换为新数据类型6 b& b' ?3 V. z9 Z+ D) W0 `
    
85.         o["a+b="], outm[a+b],     //计算并输出a+b: O. g$ J, O4 w
    
86.         o["a-b="], outm[a-b],     //计算并输出a-b3 O, ~0 I8 A  C. o% o
    
87.         o["a*c="], outm[a*c],     //计算并输出a*c
    & X6 I; a2 V# c3 t8 j* ~
88.         o["a.*b="],outm[a.*b],    //计算并输出a.*b6 ^) H( y( K: Z% B9 C' O
    
89.         o["a./b="],outm[a./b];    //计算并输出a./b

复制代码

结果：

1. a=+ y+ y- W9 b' L5 z, W8 P
   
2. 0.  1.  2.  ) ^# U\" K1 ~1 ~- I/ j' i9 b5 C
   
3. 3.  4.  5.  : I2 T. F. ^) I. R5 `5 Y' u0 B
   
4. b=
   % }- Q/ C4 x+ u0 R. _6 k
5. 1.  2.  3.  ; _  h5 \' [) D) O6 n0 b# o
   
6. 4.  5.  6.  
   6 \# J: F: W2 C8 m% W' f, g7 L
7. c=
   # `7 }1 o7 ]5 ]% Q
8. 6.  7.  1 D; S$ Z+ v- Y, P
   
9. 8.  9.  3 `\" |, ?\" b' H, [# a- T% ?, z
   
10. 0.  1.  * ~! _5 S6 Q* v) y7 B4 _; ]$ K! N3 _9 [' R
    
11. a+b=
    + D- D, c' h9 ]/ V4 \$ a: E
12. 1.  3.  5.  
    . h4 c* d2 ?1 O5 {1 O* _
13. 7.  9.  11.  7 T1 o# ^2 L\" k& @' Y8 \) U
    
14. a-b=' u' ]+ [9 U+ K  c. Y; ^
    
15. -1.  -1.  -1.  ! {( c3 v* Q9 E\" q4 O+ \3 B  d
    
16. -1.  -1.  -1.  ' ~7 k% R# D/ ^2 _
    
17. a*c=9 G! h: `5 ~! d' ]4 L; A\" i\" _) |
    
18. 8.  11.  
    9 H4 j' f# |% M3 }# D; ]$ `( O
19. 50.  62.  
    # R8 t/ a3 ^1 w2 _( d\" @; {- d( _
20. a.*b=
    / A* G! m- L0 H1 |5 B6 e2 }. Y6 J
21. 0.  2.  6.  
    ; \  g6 L) Z# t9 `: m, k2 L\" E
22. 12.  20.  30.  8 M7 U* @+ d3 k' l7 ]$ P\" t& k\" \
    
23. a./b=- Z. ~  l0 a8 G8 q5 i) o9 J8 C+ j. M* m3 D
    
24. 0.  0.5  0.66666666666666663  : T) }$ M7 h2 I7 _\" E* }: k
    
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 //定义矩阵运算
   ' J* l# h7 _* v: O
2. {
   ' X: V. v4 J: {- `0 a9 P
3.         op<0  : return[me=newtype()],
   2 ^+ |2 ~1 C; p, T3 U+ v
4.         op==0 : //重载运算符+
   & V, N+ d4 x5 |& X, i% }! E+ t6 }3 ?
5.         {% ?7 M: o& \( w
   
6.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
   . V2 a, M: O! B9 P( A
7.                 i=0, while{i<m,
   2 h\" g9 I6 P& r6 }% x
8.                         j=0, while{j<n,- c; [4 x; c% a0 I, ^9 x0 a
   
9.                                 c[i,j]=x[i,j]+y[i,j],
   + x* l- p6 m5 C$ M6 o* L8 J\" B
10.                                 j++
    9 m; l3 J3 O* W: {; C6 z
11.                         },
    . O% {- k; U1 A* w) q! k' |) l
12.                         i++2 C  ^- Y( o3 r. K, {
    
13.                 },
    $ v/ L! y% }6 q2 r- R
14.                 cast[c,me]  //强制转换为新类型me（矩阵），下同
    4 U* v- [8 t$ c, c5 |4 t+ F
15.         },
    , H% d, e$ J, \, Y
16.         op==1 : //重载运算符-: i3 i3 A; Y3 T7 E
    
17.         {& K$ N4 d7 S# o) Y5 U+ z$ W: x
    
18.                 len[x,0,&m,&n], c=new[reals,m,n].global(),/ C; A) W' n: F! O7 T
    
19.                 i=0, while{i<m,
    ' Y# B! R7 r4 `  M\" m# j$ |\" m
20.                         j=0, while{j<n,# N) @  y0 x) e( Q9 V1 y
    
21.                                 c[i,j]=x[i,j]-y[i,j],4 C) j% c& b! M/ g8 H7 K. W5 A
    
22.                                 j++\" u3 C* `4 j, u, \
    
23.                         },8 g- H$ T3 x( J1 Q
    
24.                         i++* X$ n  Z  X& D\" z# G* t
    
25.                 },
    1 ?\" x2 N2 u3 d7 p: m/ Q, v
26.                 cast[c,me]
    / S# @5 \# s, G7 M  b
27.         },' y' k3 {7 v. u/ i
    
28.         op==2 : //重载运算符*
    - b5 k! m( j# }( W, M2 E( S0 @
29.         {) |8 B( y: d5 V( d
    
30.                 len[x,0,&m,&n], len[y,0,n,&k], c=new[reals,m,k].global(),
    $ n\" j9 q5 Y- O4 g: M% ?
31.                 i=0, while{i<m,  }1 w8 @\" G\" `* W
    
32.                         j=0, while{j<k,  [2 H/ `1 M% R4 G  M
    
33.                                 c[i,j]=0.0,
    + `' i/ ^0 D  O, S
34.                                 u=0, while{u<n,
    ; r' W/ |$ H. t
35.                                         c[i,j]=c[i,j]+x[i,u]*y[u,j], u++
    2 \\" ^3 e' E0 _% E+ X
36.                                 },% D6 p- B  {% G. s
    
37.                                 j++& `/ E3 }, y2 |
    
38.                         },& I, J! E! J8 H: y2 Z  E
    
39.                         i++- A! c& [) o# ^3 g  l' f; }) w
    
40.                 },
    7 k+ w. p6 Q( ], {/ U$ ]5 w
41.                 cast[c,me]
    % ]/ |: R1 I7 E) s- Y# K
42.         },
    ( E1 g9 m7 R- }+ h
43.         op==25 ://重载运算符.*
    2 E) x! a  C& ?\" Z* p
44.         {8 {: s9 m7 O* S% \; Y
    
45.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    5 q: C. t4 q% C) y
46.                 i=0, while{i<m,& d* i& U7 d8 ^3 O\" D; r! t
    
47.                         j=0, while{j<n,
    ) U2 ?1 ~' _2 l4 e+ q* S$ l6 m
48.                                 c[i,j]=x[i,j]*y[i,j],: _1 E, Z# J- N9 N5 B9 |( Z( x
    
49.                                 j++2 b7 E! s* A3 }' N; R; _+ r
    
50.                         },, X( K  @* O; F8 F! V
    
51.                         i++
    2 x2 m8 a; P$ c2 ?
52.                 },* F9 k5 a0 E% ~( ?/ t\" K
    
53.                 cast[c,me]
    ( `! T) o' ?# N8 ?- {8 l+ [
54.         },
    \" h  W9 n5 p7 h
55.         op==26 : //重载运算符./. F: E  a9 T\" R; q0 Y
    
56.         {
    ( ~  K- b- w7 E; @  r+ V( p1 @
57.                 len[x,0,&m,&n], c=new[reals,m,n].global(),
    9 r. r1 X4 Z6 a0 d2 @
58.                 i=0, while{i<m,& {# B; {3 P3 R9 z* p
    
59.                         j=0, while{j<n,  G! Z- c) Z4 p# C; i
    
60.                                 c[i,j]=x[i,j]/y[i,j],
    7 D\" M6 A$ X( O7 A5 s
61.                                 j++; Y# ?! V) {9 _( j  \5 [
    
62.                         },
    0 g3 I! f  R' C9 Q0 E
63.                         i++
    / D9 d+ a7 f4 r9 U- I$ V
64.                 },
    9 u2 D  x5 I% \$ Q! Z
65.                 cast[c,me]3 Z7 Y. Z' c, N+ Z% H: W: e
    
66.         },
    1 j, F' R' C/ l: u$ l
67.         op==46 : //重载函数new
    2 o\" }& L9 ?7 J. v' G; L\" [' o
68.         {
    : F$ c9 F& u$ r& c$ `+ j& w
69.                 c=new[reals,y,z].global(), m=len[para], k=0,- E: F  N, A$ d: k4 G$ R
    
70.                 i=0, while{i<y,
    6 e3 r$ c( o$ j% \$ Q8 S* f9 P7 ?2 e
71.                         j=0, while{j<z, if{k>=m, return[cast(c,me)]}, c(i,j)=para[k++], j++},
    \" \5 d+ k- N) C/ e: v$ i6 s4 M\" v
72.                         i++4 I0 j- r1 T  b2 n. A
    
73.                 },
    * ]/ r. y  I# I\" J* G) I
74.                 cast[c,me]* F0 e6 q* _% c- j$ _& T
    
75.         },
    + |& x5 r8 P# j6 p3 C# T+ E
76.         op==49 : //重载函数o
    / e4 M( p& \# r+ w( \
77.         {2 \1 f5 n6 y! P+ Z5 H
    
78.                 len[x,0,&m,&n], k=0,
    8 U$ q6 f% _& U6 ]
79.                 i=0, while{i<m,
    5 s* W6 n, N. X+ {( ?7 F
80.                         o["\r\n"], k=k+2, j=0, while{j<n, k=k+o[x(i,j),"  "], j++},
    \" K5 Z$ {. A% ~9 ]
81.                         i++
    # |% u0 y. c0 D5 I\" S\" |) ]  O4 z8 M
82.                 },
    , R/ x& k- o5 L
83.                 o["\r\n"], k+25 R  V$ C. @4 h$ \0 n9 X+ G
    
84.         },* i. Z0 u' I6 A6 ~) Y! z\" ^
    
85.         nil     //该数据类型不支持该运算符的重载，返回nil) W, l2 Z! q; w/ W4 I\" f
    
86. };  {2 U% G+ }  f4 ?# ~3 A# w8 R
    
87. test(:type,a,b,c)=7 c* l8 \1 Z9 S5 J' L7 d2 `
    
88.         type=mymatrix(0,0,0,0,0,-1),  //获取新数据类型
    $ Q% E# B; g0 {# x0 l
89.         a=new[type,2,3,lu[0.,1.,2.,3.,4.,5.]],  //生成矩阵a
    1 B1 i- e- p+ G% [
90.         b=new[type,2,3,lu[1.,2.,3.,4.,5.,6.]],  //生成矩阵b& H8 s( j/ e) b* L! x+ G3 L
    
91.         c=new[type,3,2,lu[6.,7.,8.,9.,0.,1.]],  //生成矩阵c
    8 f% W& c: b\" P+ {$ y
92.         o["a=",a, "b=", b, "c=", c],  //输出a、b和c
    / [) Z5 V+ a0 K+ y: w
93.         o["a+b=", a+b],     //计算并输出a+b5 {1 d\" t! v# p$ g
    
94.         o["a-b=", a-b],     //计算并输出a-b' U# J  a% W, j6 i
    
95.         o["a*c=", a*c],     //计算并输出a*c! I9 x9 G9 ]' Q9 K' y
    
96.         o["a.*b=",a.*b],    //计算并输出a.*b
    7 f1 V; T6 @6 ?  J3 {; y4 m' q1 h
97.         o["a./b=",a./b];    //计算并输出a./b

复制代码

结果：

1. a=
   * N# R9 f# S7 p0 v3 j
2. 0.  1.  2.  
   ) P  |2 f& ^7 V: |& n! \
3. 3.  4.  5.  . |, {( o6 B8 C' X\" Q1 T% \
   
4. b=; D% h& p; V# x5 a5 i
   
5. 1.  2.  3.  / F( E, J+ K' w3 F1 j, p
   
6. 4.  5.  6.  . y+ l\" c, z7 q( I3 K0 T
   
7. c=: @  R/ ?/ |7 P  j9 P* z6 l
   
8. 6.  7.  
   ; n  f) _; B$ K2 Z  E
9. 8.  9.  
   - X) [! ~, ?4 M- Z8 W: A6 ~
10. 0.  1.  / @7 b1 M$ A) |7 i9 b* Y
    
11. a+b=
    $ K: w, r6 E# F% V# L. E; X
12. 1.  3.  5.  # ~0 R: X# \1 J/ R
    
13. 7.  9.  11.  
    ! T% i3 K( I( P& ^/ u
14. a-b=
    ; h# j+ u! s4 i! {  q9 c) ?; u
15. -1.  -1.  -1.  
    - n7 u* L6 a& `0 V
16. -1.  -1.  -1.  \" l2 u' {* h+ M. g! y$ ?8 |
    
17. a*c=
    % V7 [1 n6 C' Y6 o; c, S5 H
18. 8.  11.  / Q- O- k  x. {) R/ W; ~
    
19. 50.  62.  + W: J' V\" h4 C
    
20. a.*b=1 h/ n9 l: r+ x
    
21. 0.  2.  6.  ) r4 r$ Q9 u- l. ?7 v4 M! s4 v: g( R
    
22. 12.  20.  30.  
    ; L  B/ ]6 K& {1 N
23. a./b=
    + O' I, J8 J' a0 K
24. 0.  0.5  0.66666666666666663  
    ; T1 y\" ]' ?& Y
25. 0.75  0.80000000000000004  0.83333333333333337  

复制代码

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

www.tgchaye.com

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