Luxophia

LUX.Matrix.L2.pas
707 строк · 20.1 Кб
Перенос по словам
1
unit LUX.Matrix.L2;
2

3
interface //#################################################################### ■
4

5
uses LUX, LUX.D1, LUX.D2;
6

7
type //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【型】
8

9
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
10

11
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSingleM2
12

13
     TSingleM2 = record
14
     private
15
     public
16
       constructor Create( const _11_,_12_,
17
                                 _21_,_22_:Single );
18
       ///// 演算子
19
       class operator Negative( const V_:TSingleM2 ) :TSingleM2;
20
       class operator Positive( const V_:TSingleM2 ) :TSingleM2;
21
       class operator Add( const A_,B_:TSingleM2 ) :TSingleM2;
22
       class operator Subtract( const A_,B_:TSingleM2 ) :TSingleM2;
23
       class operator Multiply( const A_,B_:TSingleM2 ) :TSingleM2;
24
       class operator Multiply( const A_:TSingleM2; const B_:Single ) :TSingleM2;
25
       class operator Multiply( const A_:Single; const B_:TSingleM2 ) :TSingleM2;
26
       class operator Multiply( const A_:TSingle2D; const B_:TSingleM2 ) :TSingle2D;
27
       class operator Multiply( const A_:TSingleM2; const B_:TSingle2D ) :TSingle2D;
28
       class operator Divide( const A_:TSingleM2; const B_:Single ) :TSingleM2;
29
       ///// メソッド
30
       function Det :Single;
31
       class function Rotate( const Angle_:Single ) :TSingleM2; static;
32

33
     case Integer of
34
      0:( _ :array [ 1..2, 1..2 ] of Single; );
35
      1:( _11, _12,
36
          _21, _22 :Single;                  );
37
     end;
38

39
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleM2
40

41
     TDoubleM2 = record
42
     private
43
     public
44
       constructor Create( const _11_,_12_,
45
                                 _21_,_22_:Double );
46
       ///// 演算子
47
       class operator Negative( const V_:TDoubleM2 ) :TDoubleM2;
48
       class operator Positive( const V_:TDoubleM2 ) :TDoubleM2;
49
       class operator Add( const A_,B_:TDoubleM2 ) :TDoubleM2;
50
       class operator Subtract( const A_,B_:TDoubleM2 ) :TDoubleM2;
51
       class operator Multiply( const A_,B_:TDoubleM2 ) :TDoubleM2;
52
       class operator Multiply( const A_:TDoubleM2; const B_:Double ) :TDoubleM2;
53
       class operator Multiply( const A_:Double; const B_:TDoubleM2 ) :TDoubleM2;
54
       class operator Multiply( const A_:TDouble2D; const B_:TDoubleM2 ) :TDouble2D;
55
       class operator Multiply( const A_:TDoubleM2; const B_:TDouble2D ) :TDouble2D;
56
       class operator Divide( const A_:TDoubleM2; const B_:Double ) :TDoubleM2;
57
       ///// メソッド
58
       function Det :Double;
59
       class function Rotate( const Angle_:Double ) :TDoubleM2; static;
60

61
     case Integer of
62
       0: ( _ :array [ 1..2, 1..2 ] of Double; );
63
       1: ( _11, _12,
64
            _21, _22 :Double;                  );
65
     end;
66

67
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdSingleM2
68

69
     TdSingleM2 = record
70
     private
71
     public
72
       constructor Create( const _11_,_12_,
73
                                 _21_,_22_:TdSingle );
74
       ///// 演算子
75
       class operator Negative( const V_:TdSingleM2 ) :TdSingleM2;
76
       class operator Positive( const V_:TdSingleM2 ) :TdSingleM2;
77
       class operator Add( const A_,B_:TdSingleM2 ) :TdSingleM2;
78
       class operator Subtract( const A_,B_:TdSingleM2 ) :TdSingleM2;
79
       class operator Multiply( const A_,B_:TdSingleM2 ) :TdSingleM2;
80
       class operator Multiply( const A_:TdSingleM2; const B_:TdSingle ) :TdSingleM2;
81
       class operator Multiply( const A_:TdSingle; const B_:TdSingleM2 ) :TdSingleM2;
82
       class operator Multiply( const A_:TdSingle2D; const B_:TdSingleM2 ) :TdSingle2D;
83
       class operator Multiply( const A_:TdSingleM2; const B_:TdSingle2D ) :TdSingle2D;
84
       class operator Divide( const A_:TdSingleM2; const B_:TdSingle ) :TdSingleM2;
85
       ///// メソッド
86
       function Det :TdSingle;
87
       class function Rotate( const Angle_:TdSingle ) :TdSingleM2; static;
88

89
     case Integer of
90
      0:( _ :array [ 1..2, 1..2 ] of TdSingle; );
91
      1:( _11, _12,
92
          _21, _22 :TdSingle;                  );
93
     end;
94

95
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdDoubleM2
96

97
     TdDoubleM2 = record
98
     private
99
     public
100
       constructor Create( const _11_,_12_,
101
                                 _21_,_22_:TdDouble );
102
       ///// 演算子
103
       class operator Negative( const V_:TdDoubleM2 ) :TdDoubleM2;
104
       class operator Positive( const V_:TdDoubleM2 ) :TdDoubleM2;
105
       class operator Add( const A_,B_:TdDoubleM2 ) :TdDoubleM2;
106
       class operator Subtract( const A_,B_:TdDoubleM2 ) :TdDoubleM2;
107
       class operator Multiply( const A_,B_:TdDoubleM2 ) :TdDoubleM2;
108
       class operator Multiply( const A_:TdDoubleM2; const B_:TdDouble ) :TdDoubleM2;
109
       class operator Multiply( const A_:TdDouble; const B_:TdDoubleM2 ) :TdDoubleM2;
110
       class operator Multiply( const A_:TdDouble2D; const B_:TdDoubleM2 ) :TdDouble2D;
111
       class operator Multiply( const A_:TdDoubleM2; const B_:TdDouble2D ) :TdDouble2D;
112
       class operator Divide( const A_:TdDoubleM2; const B_:TdDouble ) :TdDoubleM2;
113
       ///// メソッド
114
       function Det :TdDouble;
115
       class function Rotate( const Angle_:TdDouble ) :TdDoubleM2; static;
116

117
     case Integer of
118
       0: ( _ :array [ 1..2, 1..2 ] of TdDouble; );
119
       1: ( _11, _12,
120
            _21, _22 :TdDouble;                  );
121
     end;
122

123
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
124

125
//const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
126

127
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
128

129
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
130

131
implementation //############################################################### ■
132

133
uses System.Math;
134

135
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
136

137
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSingleM2
138

139
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
140

141
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
142

143
constructor TSingleM2.Create( const _11_,_12_, _21_,_22_:Single );
144
begin
145
     _11 := _11_;  _12 := _12_;
146
     _21 := _21_;  _22 := _22_;
147
end;
148

149
///////////////////////////////////////////////////////////////////////// 演算子
150

151
class operator TSingleM2.Positive( const V_:TSingleM2 ) :TSingleM2;
152
begin
153
     with Result do
154
     begin
155
          _11 := +V_._11;  _12 := +V_._12;
156
          _21 := +V_._21;  _22 := +V_._22;
157
     end
158
end;
159

160
class operator TSingleM2.Negative( const V_:TSingleM2 ) :TSingleM2;
161
begin
162
     with Result do
163
     begin
164
          _11 := -V_._11;  _12 := -V_._12;
165
          _21 := -V_._21;  _22 := -V_._22;
166
     end
167
end;
168

169
class operator TSingleM2.Add( const A_,B_:TSingleM2 ) :TSingleM2;
170
begin
171
     with Result do
172
     begin
173
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;
174
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;
175
     end
176
end;
177

178
class operator TSingleM2.Subtract( const A_,B_:TSingleM2 ) :TSingleM2;
179
begin
180
     with Result do
181
     begin
182
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;
183
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;
184
     end
185
end;
186

187
class operator TSingleM2.Multiply( const A_,B_:TSingleM2 ) :TSingleM2;
188
begin
189
     // _11 _12    _11 _12
190
     // _21 _22 × _21 _22
191

192
     with Result do
193
     begin
194
          _11 := A_._11 * B_._11 + A_._12 * B_._21;
195
          _12 := A_._11 * B_._12 + A_._12 * B_._22;
196

197
          _21 := A_._21 * B_._11 + A_._22 * B_._21;
198
          _22 := A_._21 * B_._12 + A_._22 * B_._22;
199
     end
200
end;
201

202
class operator TSingleM2.Multiply( const A_:TSingleM2; const B_:Single ) :TSingleM2;
203
begin
204
     with Result do
205
     begin
206
          _11 := A_._11 * B_;  _12 := A_._12 * B_;
207
          _21 := A_._21 * B_;  _22 := A_._22 * B_;
208
     end
209
end;
210

211
class operator TSingleM2.Multiply( const A_:Single; const B_:TSingleM2 ) :TSingleM2;
212
begin
213
     with Result do
214
     begin
215
          _11 := A_ * B_._11;  _12 := A_ * B_._12;
216
          _21 := A_ * B_._21;  _22 := A_ * B_._22;
217
     end
218
end;
219

220
class operator TSingleM2.Multiply( const A_:TSingle2D; const B_:TSingleM2 ) :TSingle2D;
221
begin
222
     {
223
               _11 _12
224
        X Y × _21 _22
225
     }
226

227
     with Result do
228
     begin
229
          X := A_.X * B_._11 + A_.Y * B_._21;
230
          Y := A_.X * B_._12 + A_.Y * B_._22;
231
     end
232
end;
233

234
class operator TSingleM2.Multiply( const A_:TSingleM2; const B_:TSingle2D ) :TSingle2D;
235
begin
236
     {
237
       _11 _12    X
238
       _21 _22 × Y
239
     }
240

241
     with Result do
242
     begin
243
          X := A_._11 * B_.X + A_._12 * B_.Y;
244
          Y := A_._21 * B_.X + A_._22 * B_.Y;
245
     end
246
end;
247

248
class operator TSingleM2.Divide( const A_:TSingleM2; const B_:Single ) :TSingleM2;
249
begin
250
     with Result do
251
     begin
252
          _11 := A_._11 / B_;  _12 := A_._12 / B_;
253
          _21 := A_._21 / B_;  _22 := A_._22 / B_;
254
     end
255
end;
256

257
/////////////////////////////////////////////////////////////////////// メソッド
258

259
function TSingleM2.Det :Single;
260
begin
261
     Result := _11 * _22 - _21 * _12;
262
end;
263

264
class function TSingleM2.Rotate( const Angle_:Single ) :TSingleM2;
265
var
266
   S, C :Single;
267
begin
268
     SinCos( Angle_, S, C );
269

270
     with Result do
271
     begin
272
          _11 :=  C;  _12 := -S;
273
          _21 := +S;  _22 :=  C;
274
     end
275
end;
276

277
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleM2
278

279
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
280

281
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
282

283
constructor TDoubleM2.Create( const _11_,_12_, _21_,_22_:Double );
284
begin
285
     _11 := _11_;  _12 := _12_;
286
     _21 := _21_;  _22 := _22_;
287
end;
288

289
///////////////////////////////////////////////////////////////////////// 演算子
290

291
class operator TDoubleM2.Positive( const V_:TDoubleM2 ) :TDoubleM2;
292
begin
293
     with Result do
294
     begin
295
          _11 := +V_._11;  _12 := +V_._12;
296
          _21 := +V_._21;  _22 := +V_._22;
297
     end
298
end;
299

300
class operator TDoubleM2.Negative( const V_:TDoubleM2 ) :TDoubleM2;
301
begin
302
     with Result do
303
     begin
304
          _11 := -V_._11;  _12 := -V_._12;
305
          _21 := -V_._21;  _22 := -V_._22;
306
     end
307
end;
308

309
class operator TDoubleM2.Add( const A_,B_:TDoubleM2 ) :TDoubleM2;
310
begin
311
     with Result do
312
     begin
313
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;
314
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;
315
     end
316
end;
317

318
class operator TDoubleM2.Subtract( const A_,B_:TDoubleM2 ) :TDoubleM2;
319
begin
320
     with Result do
321
     begin
322
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;
323
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;
324
     end
325
end;
326

327
class operator TDoubleM2.Multiply( const A_,B_:TDoubleM2 ) :TDoubleM2;
328
begin
329
     // _11 _12    _11 _12
330
     // _21 _22 × _21 _22
331

332
     with Result do
333
     begin
334
          _11 := A_._11 * B_._11 + A_._12 * B_._21;
335
          _12 := A_._11 * B_._12 + A_._12 * B_._22;
336

337
          _21 := A_._21 * B_._11 + A_._22 * B_._21;
338
          _22 := A_._21 * B_._12 + A_._22 * B_._22;
339
     end
340
end;
341

342
class operator TDoubleM2.Multiply( const A_:TDoubleM2; const B_:Double ) :TDoubleM2;
343
begin
344
     with Result do
345
     begin
346
          _11 := A_._11 * B_;  _12 := A_._12 * B_;
347
          _21 := A_._21 * B_;  _22 := A_._22 * B_;
348
     end
349
end;
350

351
class operator TDoubleM2.Multiply( const A_:Double; const B_:TDoubleM2 ) :TDoubleM2;
352
begin
353
     with Result do
354
     begin
355
          _11 := A_ * B_._11;  _12 := A_ * B_._12;
356
          _21 := A_ * B_._21;  _22 := A_ * B_._22;
357
     end
358
end;
359

360
class operator TDoubleM2.Multiply( const A_:TDouble2D; const B_:TDoubleM2 ) :TDouble2D;
361
begin
362
     {
363
               _11 _12
364
        X Y × _21 _22
365
     }
366

367
     with Result do
368
     begin
369
          X := A_.X * B_._11 + A_.Y * B_._21;
370
          Y := A_.X * B_._12 + A_.Y * B_._22;
371
     end
372
end;
373

374
class operator TDoubleM2.Multiply( const A_:TDoubleM2; const B_:TDouble2D ) :TDouble2D;
375
begin
376
     {
377
       _11 _12    X
378
       _21 _22 × Y
379
     }
380

381
     with Result do
382
     begin
383
          X := A_._11 * B_.X + A_._12 * B_.Y;
384
          Y := A_._21 * B_.X + A_._22 * B_.Y;
385
     end
386
end;
387

388
class operator TDoubleM2.Divide( const A_:TDoubleM2; const B_:Double ) :TDoubleM2;
389
begin
390
     with Result do
391
     begin
392
          _11 := A_._11 / B_;  _12 := A_._12 / B_;
393
          _21 := A_._21 / B_;  _22 := A_._22 / B_;
394
     end
395
end;
396

397
/////////////////////////////////////////////////////////////////////// メソッド
398

399
function TDoubleM2.Det :Double;
400
begin
401
     Result := _11 * _22 - _21 * _12;
402
end;
403

404
class function TDoubleM2.Rotate( const Angle_:Double ) :TDoubleM2;
405
var
406
   S, C :Double;
407
begin
408
     SinCos( Angle_, S, C );
409

410
     with Result do
411
     begin
412
          _11 :=  C;  _12 := -S;
413
          _21 := +S;  _22 :=  C;
414
     end
415
end;
416

417
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdSingleM2
418

419
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
420

421
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
422

423
constructor TdSingleM2.Create( const _11_,_12_, _21_,_22_:TdSingle );
424
begin
425
     _11 := _11_;  _12 := _12_;
426
     _21 := _21_;  _22 := _22_;
427
end;
428

429
///////////////////////////////////////////////////////////////////////// 演算子
430

431
class operator TdSingleM2.Positive( const V_:TdSingleM2 ) :TdSingleM2;
432
begin
433
     with Result do
434
     begin
435
          _11 := +V_._11;  _12 := +V_._12;
436
          _21 := +V_._21;  _22 := +V_._22;
437
     end
438
end;
439

440
class operator TdSingleM2.Negative( const V_:TdSingleM2 ) :TdSingleM2;
441
begin
442
     with Result do
443
     begin
444
          _11 := -V_._11;  _12 := -V_._12;
445
          _21 := -V_._21;  _22 := -V_._22;
446
     end
447
end;
448

449
class operator TdSingleM2.Add( const A_,B_:TdSingleM2 ) :TdSingleM2;
450
begin
451
     with Result do
452
     begin
453
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;
454
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;
455
     end
456
end;
457

458
class operator TdSingleM2.Subtract( const A_,B_:TdSingleM2 ) :TdSingleM2;
459
begin
460
     with Result do
461
     begin
462
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;
463
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;
464
     end
465
end;
466

467
class operator TdSingleM2.Multiply( const A_,B_:TdSingleM2 ) :TdSingleM2;
468
begin
469
     // _11 _12    _11 _12
470
     // _21 _22 × _21 _22
471

472
     with Result do
473
     begin
474
          _11 := A_._11 * B_._11 + A_._12 * B_._21;
475
          _12 := A_._11 * B_._12 + A_._12 * B_._22;
476

477
          _21 := A_._21 * B_._11 + A_._22 * B_._21;
478
          _22 := A_._21 * B_._12 + A_._22 * B_._22;
479
     end
480
end;
481

482
class operator TdSingleM2.Multiply( const A_:TdSingleM2; const B_:TdSingle ) :TdSingleM2;
483
begin
484
     with Result do
485
     begin
486
          _11 := A_._11 * B_;  _12 := A_._12 * B_;
487
          _21 := A_._21 * B_;  _22 := A_._22 * B_;
488
     end
489
end;
490

491
class operator TdSingleM2.Multiply( const A_:TdSingle; const B_:TdSingleM2 ) :TdSingleM2;
492
begin
493
     with Result do
494
     begin
495
          _11 := A_ * B_._11;  _12 := A_ * B_._12;
496
          _21 := A_ * B_._21;  _22 := A_ * B_._22;
497
     end
498
end;
499

500
class operator TdSingleM2.Multiply( const A_:TdSingle2D; const B_:TdSingleM2 ) :TdSingle2D;
501
begin
502
     {
503
               _11 _12
504
        X Y × _21 _22
505
     }
506

507
     with Result do
508
     begin
509
          X := A_.X * B_._11 + A_.Y * B_._21;
510
          Y := A_.X * B_._12 + A_.Y * B_._22;
511
     end
512
end;
513

514
class operator TdSingleM2.Multiply( const A_:TdSingleM2; const B_:TdSingle2D ) :TdSingle2D;
515
begin
516
     {
517
       _11 _12    X
518
       _21 _22 × Y
519
     }
520

521
     with Result do
522
     begin
523
          X := A_._11 * B_.X + A_._12 * B_.Y;
524
          Y := A_._21 * B_.X + A_._22 * B_.Y;
525
     end
526
end;
527

528
class operator TdSingleM2.Divide( const A_:TdSingleM2; const B_:TdSingle ) :TdSingleM2;
529
begin
530
     with Result do
531
     begin
532
          _11 := A_._11 / B_;  _12 := A_._12 / B_;
533
          _21 := A_._21 / B_;  _22 := A_._22 / B_;
534
     end
535
end;
536

537
/////////////////////////////////////////////////////////////////////// メソッド
538

539
function TdSingleM2.Det :TdSingle;
540
begin
541
     Result := _11 * _22 - _21 * _12;
542
end;
543

544
class function TdSingleM2.Rotate( const Angle_:TdSingle ) :TdSingleM2;
545
var
546
   S, C :TdSingle;
547
begin
548
     SinCos( Angle_, S, C );
549

550
     with Result do
551
     begin
552
          _11 :=  C;  _12 := -S;
553
          _21 := +S;  _22 :=  C;
554
     end
555
end;
556

557
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdDoubleM2
558

559
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
560

561
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
562

563
constructor TdDoubleM2.Create( const _11_,_12_, _21_,_22_:TdDouble );
564
begin
565
     _11 := _11_;  _12 := _12_;
566
     _21 := _21_;  _22 := _22_;
567
end;
568

569
///////////////////////////////////////////////////////////////////////// 演算子
570

571
class operator TdDoubleM2.Positive( const V_:TdDoubleM2 ) :TdDoubleM2;
572
begin
573
     with Result do
574
     begin
575
          _11 := +V_._11;  _12 := +V_._12;
576
          _21 := +V_._21;  _22 := +V_._22;
577
     end
578
end;
579

580
class operator TdDoubleM2.Negative( const V_:TdDoubleM2 ) :TdDoubleM2;
581
begin
582
     with Result do
583
     begin
584
          _11 := -V_._11;  _12 := -V_._12;
585
          _21 := -V_._21;  _22 := -V_._22;
586
     end
587
end;
588

589
class operator TdDoubleM2.Add( const A_,B_:TdDoubleM2 ) :TdDoubleM2;
590
begin
591
     with Result do
592
     begin
593
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;
594
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;
595
     end
596
end;
597

598
class operator TdDoubleM2.Subtract( const A_,B_:TdDoubleM2 ) :TdDoubleM2;
599
begin
600
     with Result do
601
     begin
602
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;
603
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;
604
     end
605
end;
606

607
class operator TdDoubleM2.Multiply( const A_,B_:TdDoubleM2 ) :TdDoubleM2;
608
begin
609
     // _11 _12    _11 _12
610
     // _21 _22 × _21 _22
611

612
     with Result do
613
     begin
614
          _11 := A_._11 * B_._11 + A_._12 * B_._21;
615
          _12 := A_._11 * B_._12 + A_._12 * B_._22;
616

617
          _21 := A_._21 * B_._11 + A_._22 * B_._21;
618
          _22 := A_._21 * B_._12 + A_._22 * B_._22;
619
     end
620
end;
621

622
class operator TdDoubleM2.Multiply( const A_:TdDoubleM2; const B_:TdDouble ) :TdDoubleM2;
623
begin
624
     with Result do
625
     begin
626
          _11 := A_._11 * B_;  _12 := A_._12 * B_;
627
          _21 := A_._21 * B_;  _22 := A_._22 * B_;
628
     end
629
end;
630

631
class operator TdDoubleM2.Multiply( const A_:TdDouble; const B_:TdDoubleM2 ) :TdDoubleM2;
632
begin
633
     with Result do
634
     begin
635
          _11 := A_ * B_._11;  _12 := A_ * B_._12;
636
          _21 := A_ * B_._21;  _22 := A_ * B_._22;
637
     end
638
end;
639

640
class operator TdDoubleM2.Multiply( const A_:TdDouble2D; const B_:TdDoubleM2 ) :TdDouble2D;
641
begin
642
     {
643
               _11 _12
644
        X Y × _21 _22
645
     }
646

647
     with Result do
648
     begin
649
          X := A_.X * B_._11 + A_.Y * B_._21;
650
          Y := A_.X * B_._12 + A_.Y * B_._22;
651
     end
652
end;
653

654
class operator TdDoubleM2.Multiply( const A_:TdDoubleM2; const B_:TdDouble2D ) :TdDouble2D;
655
begin
656
     {
657
       _11 _12    X
658
       _21 _22 × Y
659
     }
660

661
     with Result do
662
     begin
663
          X := A_._11 * B_.X + A_._12 * B_.Y;
664
          Y := A_._21 * B_.X + A_._22 * B_.Y;
665
     end
666
end;
667

668
class operator TdDoubleM2.Divide( const A_:TdDoubleM2; const B_:TdDouble ) :TdDoubleM2;
669
begin
670
     with Result do
671
     begin
672
          _11 := A_._11 / B_;  _12 := A_._12 / B_;
673
          _21 := A_._21 / B_;  _22 := A_._22 / B_;
674
     end
675
end;
676

677
/////////////////////////////////////////////////////////////////////// メソッド
678

679
function TdDoubleM2.Det :TdDouble;
680
begin
681
     Result := _11 * _22 - _21 * _12;
682
end;
683

684
class function TdDoubleM2.Rotate( const Angle_:TdDouble ) :TdDoubleM2;
685
var
686
   S, C :TdDouble;
687
begin
688
     SinCos( Angle_, S, C );
689

690
     with Result do
691
     begin
692
          _11 :=  C;  _12 := -S;
693
          _21 := +S;  _22 :=  C;
694
     end
695
end;
696

697
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
698

699
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
700

701
//############################################################################## □
702

703
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
704

705
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 終了化
706

707
end. //######################################################################### ■
708
Luxophia

Использование cookies
