Luxophia

1
unit LUX.M2;
2

3
interface
4

5
uses
6
  System.Math,
7

8
  LUX,
9
  LUX.D1,
10
  LUX.D2;
11

12
type
13

14
  TSingleM2 = record
15
  private
16
    function GetM(const Y_, X_: Integer): Single;
17
    procedure SetM(const Y_, X_: Integer; const M_: Single);
18
    function GetAxisX: TSingle2D;
19
    procedure SetAxisX(const AxisX_: TSingle2D);
20
    function GetAxisY: TSingle2D;
21
    procedure SetAxisY(const AxisY_: TSingle2D);
22
  public
23
    constructor Create(const _11_, _12_, _21_, _22_: Single);
24
    class operator Negative(const V_: TSingleM2): TSingleM2;
25
    class operator Positive(const V_: TSingleM2): TSingleM2;
26
    class operator Add(const A_, B_: TSingleM2): TSingleM2;
27
    class operator Subtract(const A_, B_: TSingleM2): TSingleM2;
28
    class operator Multiply(const A_, B_: TSingleM2): TSingleM2;
29
    class operator Multiply(const A_: TSingleM2; const B_: Single): TSingleM2;
30
    class operator Multiply(const A_: Single; const B_: TSingleM2): TSingleM2;
31
    class operator Multiply(const A_: TSingle2D; const B_: TSingleM2)
32
      : TSingle2D;
33
    class operator Multiply(const A_: TSingleM2; const B_: TSingle2D)
34
      : TSingle2D;
35
    class operator Divide(const A_: TSingleM2; const B_: Single): TSingleM2;
36
    property M[const Y_, X_: Integer]: Single read GetM write SetM; default;
37
    property AxisX: TSingle2D read GetAxisX write SetAxisX;
38
    property AxisY: TSingle2D read GetAxisY write SetAxisY;
39
    function Det: Single;
40
    function Adjugate: TSingleM2;
41
    function Inverse: TSingleM2;
42
    class function Rotate(const Angle_: Single): TSingleM2; static;
43

44
    case Integer of
45
      0:
46
        (_: array [1 .. 2, 1 .. 2] of Single;);
47
      1:
48
        (_11, _12, _21, _22: Single;
49
        );
50
  end;
51

52
  TDoubleM2 = record
53
  private
54
    function GetM(const Y_, X_: Integer): Double;
55
    procedure SetM(const Y_, X_: Integer; const M_: Double);
56
    function GetAxisX: TDouble2D;
57
    procedure SetAxisX(const AxisX_: TDouble2D);
58
    function GetAxisY: TDouble2D;
59
    procedure SetAxisY(const AxisY_: TDouble2D);
60
  public
61
    constructor Create(const _11_, _12_, _21_, _22_: Double);
62
    class operator Negative(const V_: TDoubleM2): TDoubleM2;
63
    class operator Positive(const V_: TDoubleM2): TDoubleM2;
64
    class operator Add(const A_, B_: TDoubleM2): TDoubleM2;
65
    class operator Subtract(const A_, B_: TDoubleM2): TDoubleM2;
66
    class operator Multiply(const A_, B_: TDoubleM2): TDoubleM2;
67
    class operator Multiply(const A_: TDoubleM2; const B_: Double): TDoubleM2;
68
    class operator Multiply(const A_: Double; const B_: TDoubleM2): TDoubleM2;
69
    class operator Multiply(const A_: TDouble2D; const B_: TDoubleM2)
70
      : TDouble2D;
71
    class operator Multiply(const A_: TDoubleM2; const B_: TDouble2D)
72
      : TDouble2D;
73
    class operator Divide(const A_: TDoubleM2; const B_: Double): TDoubleM2;
74
    property M[const Y_, X_: Integer]: Double read GetM write SetM; default;
75
    property AxisX: TDouble2D read GetAxisX write SetAxisX;
76
    property AxisY: TDouble2D read GetAxisY write SetAxisY;
77
    function Det: Double;
78
    function Adjugate: TDoubleM2;
79
    function Inverse: TDoubleM2;
80
    class function Rotate(const Angle_: Double): TDoubleM2; static;
81

82
    case Integer of
83
      0:
84
        (_: array [1 .. 2, 1 .. 2] of Double;);
85
      1:
86
        (_11, _12, _21, _22: Double;
87
        );
88
  end;
89

90
  TdSingleM2 = record
91
  private
92
    function GetM(const Y_, X_: Integer): TdSingle;
93
    procedure SetM(const Y_, X_: Integer; const M_: TdSingle);
94
    function GetAxisX: TdSingle2D;
95
    procedure SetAxisX(const AxisX_: TdSingle2D);
96
    function GetAxisY: TdSingle2D;
97
    procedure SetAxisY(const AxisY_: TdSingle2D);
98
  public
99
    constructor Create(const _11_, _12_, _21_, _22_: TdSingle);
100
    class operator Negative(const V_: TdSingleM2): TdSingleM2;
101
    class operator Positive(const V_: TdSingleM2): TdSingleM2;
102
    class operator Add(const A_, B_: TdSingleM2): TdSingleM2;
103
    class operator Subtract(const A_, B_: TdSingleM2): TdSingleM2;
104
    class operator Multiply(const A_, B_: TdSingleM2): TdSingleM2;
105
    class operator Multiply(const A_: TdSingleM2; const B_: TdSingle)
106
      : TdSingleM2;
107
    class operator Multiply(const A_: TdSingle; const B_: TdSingleM2)
108
      : TdSingleM2;
109
    class operator Multiply(const A_: TdSingle2D; const B_: TdSingleM2)
110
      : TdSingle2D;
111
    class operator Multiply(const A_: TdSingleM2; const B_: TdSingle2D)
112
      : TdSingle2D;
113
    class operator Divide(const A_: TdSingleM2; const B_: TdSingle): TdSingleM2;
114
    property M[const Y_, X_: Integer]: TdSingle read GetM write SetM; default;
115
    property AxisX: TdSingle2D read GetAxisX write SetAxisX;
116
    property AxisY: TdSingle2D read GetAxisY write SetAxisY;
117
    function Det: TdSingle;
118
    function Adjugate: TdSingleM2;
119
    function Inverse: TdSingleM2;
120
    class function Rotate(const Angle_: TdSingle): TdSingleM2; static;
121

122
    case Integer of
123
      0:
124
        (_: array [1 .. 2, 1 .. 2] of TdSingle;);
125
      1:
126
        (_11, _12, _21, _22: TdSingle;
127
        );
128
  end;
129

130
  TdDoubleM2 = record
131
  private
132
    function GetM(const Y_, X_: Integer): TdDouble;
133
    procedure SetM(const Y_, X_: Integer; const M_: TdDouble);
134
    function GetAxisX: TdDouble2D;
135
    procedure SetAxisX(const AxisX_: TdDouble2D);
136
    function GetAxisY: TdDouble2D;
137
    procedure SetAxisY(const AxisY_: TdDouble2D);
138
  public
139
    constructor Create(const _11_, _12_, _21_, _22_: TdDouble);
140
    class operator Negative(const V_: TdDoubleM2): TdDoubleM2;
141
    class operator Positive(const V_: TdDoubleM2): TdDoubleM2;
142
    class operator Add(const A_, B_: TdDoubleM2): TdDoubleM2;
143
    class operator Subtract(const A_, B_: TdDoubleM2): TdDoubleM2;
144
    class operator Multiply(const A_, B_: TdDoubleM2): TdDoubleM2;
145
    class operator Multiply(const A_: TdDoubleM2; const B_: TdDouble)
146
      : TdDoubleM2;
147
    class operator Multiply(const A_: TdDouble; const B_: TdDoubleM2)
148
      : TdDoubleM2;
149
    class operator Multiply(const A_: TdDouble2D; const B_: TdDoubleM2)
150
      : TdDouble2D;
151
    class operator Multiply(const A_: TdDoubleM2; const B_: TdDouble2D)
152
      : TdDouble2D;
153
    class operator Divide(const A_: TdDoubleM2; const B_: TdDouble): TdDoubleM2;
154
    property M[const Y_, X_: Integer]: TdDouble read GetM write SetM; default;
155
    property AxisX: TdDouble2D read GetAxisX write SetAxisX;
156
    property AxisY: TdDouble2D read GetAxisY write SetAxisY;
157
    function Det: TdDouble;
158
    function Adjugate: TdDoubleM2;
159
    function Inverse: TdDoubleM2;
160
    class function Rotate(const Angle_: TdDouble): TdDoubleM2; static;
161

162
    case Integer of
163
      0:
164
        (_: array [1 .. 2, 1 .. 2] of TdDouble;);
165
      1:
166
        (_11, _12, _21, _22: TdDouble;
167
        );
168
  end;
169

170
implementation // -------------------------------------------------------------
171

172
function TSingleM2.GetM(const Y_, X_: Integer): Single;
173
begin
174
  Result := _[Y_, X_];
175
end;
176

177
procedure TSingleM2.SetM(const Y_, X_: Integer; const M_: Single);
178
begin
179
  _[Y_, X_] := M_;
180
end;
181

182
// ------------------------------------------------------------------------------
183

184
function TSingleM2.GetAxisX: TSingle2D;
185
begin
186
  with Result do
187
  begin
188
    X := _11; { X := _12; }
189
    Y := _21; { Y := _22; }
190
  end;
191
end;
192

193
procedure TSingleM2.SetAxisX(const AxisX_: TSingle2D);
194
begin
195
  with AxisX_ do
196
  begin
197
    _11 := X; { _12 := X; }
198
    _21 := Y; { _22 := Y; }
199
  end;
200
end;
201

202
function TSingleM2.GetAxisY: TSingle2D;
203
begin
204
  with Result do
205
  begin
206
    { X := _11; } X := _12;
207
    { Y := _21; } Y := _22;
208
  end;
209
end;
210

211
procedure TSingleM2.SetAxisY(const AxisY_: TSingle2D);
212
begin
213
  with AxisY_ do
214
  begin
215
    { _11 := X; } _12 := X;
216
    { _21 := Y; } _22 := Y;
217
  end;
218
end;
219

220
constructor TSingleM2.Create(const _11_, _12_, _21_, _22_: Single);
221
begin
222
  _11 := _11_;
223
  _12 := _12_;
224
  _21 := _21_;
225
  _22 := _22_;
226
end;
227

228
class operator TSingleM2.Positive(const V_: TSingleM2): TSingleM2;
229
begin
230
  with Result do
231
  begin
232
    _11 := +V_._11;
233
    _12 := +V_._12;
234
    _21 := +V_._21;
235
    _22 := +V_._22;
236
  end
237
end;
238

239
class operator TSingleM2.Negative(const V_: TSingleM2): TSingleM2;
240
begin
241
  with Result do
242
  begin
243
    _11 := -V_._11;
244
    _12 := -V_._12;
245
    _21 := -V_._21;
246
    _22 := -V_._22;
247
  end
248
end;
249

250
class operator TSingleM2.Add(const A_, B_: TSingleM2): TSingleM2;
251
begin
252
  with Result do
253
  begin
254
    _11 := A_._11 + B_._11;
255
    _12 := A_._12 + B_._12;
256
    _21 := A_._21 + B_._21;
257
    _22 := A_._22 + B_._22;
258
  end
259
end;
260

261
class operator TSingleM2.Subtract(const A_, B_: TSingleM2): TSingleM2;
262
begin
263
  with Result do
264
  begin
265
    _11 := A_._11 - B_._11;
266
    _12 := A_._12 - B_._12;
267
    _21 := A_._21 - B_._21;
268
    _22 := A_._22 - B_._22;
269
  end
270
end;
271

272
class operator TSingleM2.Multiply(const A_, B_: TSingleM2): TSingleM2;
273
begin
274
  // _11 _12    _11 _12
275
  // _21 _22 × _21 _22
276

277
  with Result do
278
  begin
279
    _11 := A_._11 * B_._11 + A_._12 * B_._21;
280
    _12 := A_._11 * B_._12 + A_._12 * B_._22;
281

282
    _21 := A_._21 * B_._11 + A_._22 * B_._21;
283
    _22 := A_._21 * B_._12 + A_._22 * B_._22;
284
  end
285
end;
286

287
class operator TSingleM2.Multiply(const A_: TSingleM2; const B_: Single)
288
  : TSingleM2;
289
begin
290
  with Result do
291
  begin
292
    _11 := A_._11 * B_;
293
    _12 := A_._12 * B_;
294
    _21 := A_._21 * B_;
295
    _22 := A_._22 * B_;
296
  end
297
end;
298

299
class operator TSingleM2.Multiply(const A_: Single; const B_: TSingleM2)
300
  : TSingleM2;
301
begin
302
  with Result do
303
  begin
304
    _11 := A_ * B_._11;
305
    _12 := A_ * B_._12;
306
    _21 := A_ * B_._21;
307
    _22 := A_ * B_._22;
308
  end
309
end;
310

311
class operator TSingleM2.Multiply(const A_: TSingle2D; const B_: TSingleM2)
312
  : TSingle2D;
313
begin
314
  {
315
    _11 _12
316
    X Y × _21 _22
317
  }
318

319
  with Result do
320
  begin
321
    X := A_.X * B_._11 + A_.Y * B_._21;
322
    Y := A_.X * B_._12 + A_.Y * B_._22;
323
  end
324
end;
325

326
class operator TSingleM2.Multiply(const A_: TSingleM2; const B_: TSingle2D)
327
  : TSingle2D;
328
begin
329
  {
330
    _11 _12    X
331
    _21 _22 × Y
332
  }
333

334
  with Result do
335
  begin
336
    X := A_._11 * B_.X + A_._12 * B_.Y;
337
    Y := A_._21 * B_.X + A_._22 * B_.Y;
338
  end
339
end;
340

341
class operator TSingleM2.Divide(const A_: TSingleM2; const B_: Single)
342
  : TSingleM2;
343
begin
344
  with Result do
345
  begin
346
    _11 := A_._11 / B_;
347
    _12 := A_._12 / B_;
348
    _21 := A_._21 / B_;
349
    _22 := A_._22 / B_;
350
  end
351
end;
352

353
function TSingleM2.Det: Single;
354
begin
355
  Result := _11 * _22 - _21 * _12;
356
end;
357

358
function TSingleM2.Adjugate: TSingleM2;
359
begin
360
  Result._11 := +_22;
361
  Result._12 := -_12;
362
  Result._21 := -_21;
363
  Result._22 := +_11;
364
end;
365

366
function TSingleM2.Inverse: TSingleM2;
367
begin
368
  Result := Adjugate / Det;
369
end;
370

371
// ------------------------------------------------------------------------------
372

373
class function TSingleM2.Rotate(const Angle_: Single): TSingleM2;
374
var
375
  S, C: Single;
376
begin
377
  SinCos(Angle_, S, C);
378

379
  with Result do
380
  begin
381
    _11 := C;
382
    _12 := -S;
383
    _21 := +S;
384
    _22 := C;
385
  end
386
end;
387

388
function TDoubleM2.GetM(const Y_, X_: Integer): Double;
389
begin
390
  Result := _[Y_, X_];
391
end;
392

393
procedure TDoubleM2.SetM(const Y_, X_: Integer; const M_: Double);
394
begin
395
  _[Y_, X_] := M_;
396
end;
397

398
// ------------------------------------------------------------------------------
399

400
function TDoubleM2.GetAxisX: TDouble2D;
401
begin
402
  with Result do
403
  begin
404
    X := _11; { X := _12; }
405
    Y := _21; { Y := _22; }
406
  end;
407
end;
408

409
procedure TDoubleM2.SetAxisX(const AxisX_: TDouble2D);
410
begin
411
  with AxisX_ do
412
  begin
413
    _11 := X; { _12 := X; }
414
    _21 := Y; { _22 := Y; }
415
  end;
416
end;
417

418
function TDoubleM2.GetAxisY: TDouble2D;
419
begin
420
  with Result do
421
  begin
422
    { X := _11; } X := _12;
423
    { Y := _21; } Y := _22;
424
  end;
425
end;
426

427
procedure TDoubleM2.SetAxisY(const AxisY_: TDouble2D);
428
begin
429
  with AxisY_ do
430
  begin
431
    { _11 := X; } _12 := X;
432
    { _21 := Y; } _22 := Y;
433
  end;
434
end;
435

436
constructor TDoubleM2.Create(const _11_, _12_, _21_, _22_: Double);
437
begin
438
  _11 := _11_;
439
  _12 := _12_;
440
  _21 := _21_;
441
  _22 := _22_;
442
end;
443

444
class operator TDoubleM2.Positive(const V_: TDoubleM2): TDoubleM2;
445
begin
446
  with Result do
447
  begin
448
    _11 := +V_._11;
449
    _12 := +V_._12;
450
    _21 := +V_._21;
451
    _22 := +V_._22;
452
  end
453
end;
454

455
class operator TDoubleM2.Negative(const V_: TDoubleM2): TDoubleM2;
456
begin
457
  with Result do
458
  begin
459
    _11 := -V_._11;
460
    _12 := -V_._12;
461
    _21 := -V_._21;
462
    _22 := -V_._22;
463
  end
464
end;
465

466
class operator TDoubleM2.Add(const A_, B_: TDoubleM2): TDoubleM2;
467
begin
468
  with Result do
469
  begin
470
    _11 := A_._11 + B_._11;
471
    _12 := A_._12 + B_._12;
472
    _21 := A_._21 + B_._21;
473
    _22 := A_._22 + B_._22;
474
  end
475
end;
476

477
class operator TDoubleM2.Subtract(const A_, B_: TDoubleM2): TDoubleM2;
478
begin
479
  with Result do
480
  begin
481
    _11 := A_._11 - B_._11;
482
    _12 := A_._12 - B_._12;
483
    _21 := A_._21 - B_._21;
484
    _22 := A_._22 - B_._22;
485
  end
486
end;
487

488
class operator TDoubleM2.Multiply(const A_, B_: TDoubleM2): TDoubleM2;
489
begin
490
  // _11 _12    _11 _12
491
  // _21 _22 × _21 _22
492

493
  with Result do
494
  begin
495
    _11 := A_._11 * B_._11 + A_._12 * B_._21;
496
    _12 := A_._11 * B_._12 + A_._12 * B_._22;
497

498
    _21 := A_._21 * B_._11 + A_._22 * B_._21;
499
    _22 := A_._21 * B_._12 + A_._22 * B_._22;
500
  end
501
end;
502

503
class operator TDoubleM2.Multiply(const A_: TDoubleM2; const B_: Double)
504
  : TDoubleM2;
505
begin
506
  with Result do
507
  begin
508
    _11 := A_._11 * B_;
509
    _12 := A_._12 * B_;
510
    _21 := A_._21 * B_;
511
    _22 := A_._22 * B_;
512
  end
513
end;
514

515
class operator TDoubleM2.Multiply(const A_: Double; const B_: TDoubleM2)
516
  : TDoubleM2;
517
begin
518
  with Result do
519
  begin
520
    _11 := A_ * B_._11;
521
    _12 := A_ * B_._12;
522
    _21 := A_ * B_._21;
523
    _22 := A_ * B_._22;
524
  end
525
end;
526

527
class operator TDoubleM2.Multiply(const A_: TDouble2D; const B_: TDoubleM2)
528
  : TDouble2D;
529
begin
530
  {
531
    _11 _12
532
    X Y × _21 _22
533
  }
534

535
  with Result do
536
  begin
537
    X := A_.X * B_._11 + A_.Y * B_._21;
538
    Y := A_.X * B_._12 + A_.Y * B_._22;
539
  end
540
end;
541

542
class operator TDoubleM2.Multiply(const A_: TDoubleM2; const B_: TDouble2D)
543
  : TDouble2D;
544
begin
545
  {
546
    _11 _12    X
547
    _21 _22 × Y
548
  }
549

550
  with Result do
551
  begin
552
    X := A_._11 * B_.X + A_._12 * B_.Y;
553
    Y := A_._21 * B_.X + A_._22 * B_.Y;
554
  end
555
end;
556

557
class operator TDoubleM2.Divide(const A_: TDoubleM2; const B_: Double)
558
  : TDoubleM2;
559
begin
560
  with Result do
561
  begin
562
    _11 := A_._11 / B_;
563
    _12 := A_._12 / B_;
564
    _21 := A_._21 / B_;
565
    _22 := A_._22 / B_;
566
  end
567
end;
568

569
function TDoubleM2.Det: Double;
570
begin
571
  Result := _11 * _22 - _21 * _12;
572
end;
573

574
function TDoubleM2.Adjugate: TDoubleM2;
575
begin
576
  Result._11 := +_22;
577
  Result._12 := -_12;
578
  Result._21 := -_21;
579
  Result._22 := +_11;
580
end;
581

582
function TDoubleM2.Inverse: TDoubleM2;
583
begin
584
  Result := Adjugate / Det;
585
end;
586

587
// ------------------------------------------------------------------------------
588

589
class function TDoubleM2.Rotate(const Angle_: Double): TDoubleM2;
590
var
591
  S, C: Double;
592
begin
593
  SinCos(Angle_, S, C);
594

595
  with Result do
596
  begin
597
    _11 := C;
598
    _12 := -S;
599
    _21 := +S;
600
    _22 := C;
601
  end
602
end;
603

604
function TdSingleM2.GetM(const Y_, X_: Integer): TdSingle;
605
begin
606
  Result := _[Y_, X_];
607
end;
608

609
procedure TdSingleM2.SetM(const Y_, X_: Integer; const M_: TdSingle);
610
begin
611
  _[Y_, X_] := M_;
612
end;
613

614
// ------------------------------------------------------------------------------
615

616
function TdSingleM2.GetAxisX: TdSingle2D;
617
begin
618
  with Result do
619
  begin
620
    X := _11; { X := _12; }
621
    Y := _21; { Y := _22; }
622
  end;
623
end;
624

625
procedure TdSingleM2.SetAxisX(const AxisX_: TdSingle2D);
626
begin
627
  with AxisX_ do
628
  begin
629
    _11 := X; { _12 := X; }
630
    _21 := Y; { _22 := Y; }
631
  end;
632
end;
633

634
function TdSingleM2.GetAxisY: TdSingle2D;
635
begin
636
  with Result do
637
  begin
638
    { X := _11; } X := _12;
639
    { Y := _21; } Y := _22;
640
  end;
641
end;
642

643
procedure TdSingleM2.SetAxisY(const AxisY_: TdSingle2D);
644
begin
645
  with AxisY_ do
646
  begin
647
    { _11 := X; } _12 := X;
648
    { _21 := Y; } _22 := Y;
649
  end;
650
end;
651

652
// &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
653

654
constructor TdSingleM2.Create(const _11_, _12_, _21_, _22_: TdSingle);
655
begin
656
  _11 := _11_;
657
  _12 := _12_;
658
  _21 := _21_;
659
  _22 := _22_;
660
end;
661

662
class operator TdSingleM2.Positive(const V_: TdSingleM2): TdSingleM2;
663
begin
664
  with Result do
665
  begin
666
    _11 := +V_._11;
667
    _12 := +V_._12;
668
    _21 := +V_._21;
669
    _22 := +V_._22;
670
  end
671
end;
672

673
class operator TdSingleM2.Negative(const V_: TdSingleM2): TdSingleM2;
674
begin
675
  with Result do
676
  begin
677
    _11 := -V_._11;
678
    _12 := -V_._12;
679
    _21 := -V_._21;
680
    _22 := -V_._22;
681
  end
682
end;
683

684
class operator TdSingleM2.Add(const A_, B_: TdSingleM2): TdSingleM2;
685
begin
686
  with Result do
687
  begin
688
    _11 := A_._11 + B_._11;
689
    _12 := A_._12 + B_._12;
690
    _21 := A_._21 + B_._21;
691
    _22 := A_._22 + B_._22;
692
  end
693
end;
694

695
class operator TdSingleM2.Subtract(const A_, B_: TdSingleM2): TdSingleM2;
696
begin
697
  with Result do
698
  begin
699
    _11 := A_._11 - B_._11;
700
    _12 := A_._12 - B_._12;
701
    _21 := A_._21 - B_._21;
702
    _22 := A_._22 - B_._22;
703
  end
704
end;
705

706
class operator TdSingleM2.Multiply(const A_, B_: TdSingleM2): TdSingleM2;
707
begin
708
  // _11 _12    _11 _12
709
  // _21 _22 × _21 _22
710

711
  with Result do
712
  begin
713
    _11 := A_._11 * B_._11 + A_._12 * B_._21;
714
    _12 := A_._11 * B_._12 + A_._12 * B_._22;
715

716
    _21 := A_._21 * B_._11 + A_._22 * B_._21;
717
    _22 := A_._21 * B_._12 + A_._22 * B_._22;
718
  end
719
end;
720

721
class operator TdSingleM2.Multiply(const A_: TdSingleM2; const B_: TdSingle)
722
  : TdSingleM2;
723
begin
724
  with Result do
725
  begin
726
    _11 := A_._11 * B_;
727
    _12 := A_._12 * B_;
728
    _21 := A_._21 * B_;
729
    _22 := A_._22 * B_;
730
  end
731
end;
732

733
class operator TdSingleM2.Multiply(const A_: TdSingle; const B_: TdSingleM2)
734
  : TdSingleM2;
735
begin
736
  with Result do
737
  begin
738
    _11 := A_ * B_._11;
739
    _12 := A_ * B_._12;
740
    _21 := A_ * B_._21;
741
    _22 := A_ * B_._22;
742
  end
743
end;
744

745
class operator TdSingleM2.Multiply(const A_: TdSingle2D; const B_: TdSingleM2)
746
  : TdSingle2D;
747
begin
748
  {
749
    _11 _12
750
    X Y × _21 _22
751
  }
752

753
  with Result do
754
  begin
755
    X := A_.X * B_._11 + A_.Y * B_._21;
756
    Y := A_.X * B_._12 + A_.Y * B_._22;
757
  end
758
end;
759

760
class operator TdSingleM2.Multiply(const A_: TdSingleM2; const B_: TdSingle2D)
761
  : TdSingle2D;
762
begin
763
  {
764
    _11 _12    X
765
    _21 _22 × Y
766
  }
767

768
  with Result do
769
  begin
770
    X := A_._11 * B_.X + A_._12 * B_.Y;
771
    Y := A_._21 * B_.X + A_._22 * B_.Y;
772
  end
773
end;
774

775
class operator TdSingleM2.Divide(const A_: TdSingleM2; const B_: TdSingle)
776
  : TdSingleM2;
777
begin
778
  with Result do
779
  begin
780
    _11 := A_._11 / B_;
781
    _12 := A_._12 / B_;
782
    _21 := A_._21 / B_;
783
    _22 := A_._22 / B_;
784
  end
785
end;
786

787
function TdSingleM2.Det: TdSingle;
788
begin
789
  Result := _11 * _22 - _21 * _12;
790
end;
791

792
function TdSingleM2.Adjugate: TdSingleM2;
793
begin
794
  Result._11 := +_22;
795
  Result._12 := -_12;
796
  Result._21 := -_21;
797
  Result._22 := +_11;
798
end;
799

800
function TdSingleM2.Inverse: TdSingleM2;
801
begin
802
  Result := Adjugate / Det;
803
end;
804

805
// ------------------------------------------------------------------------------
806

807
class function TdSingleM2.Rotate(const Angle_: TdSingle): TdSingleM2;
808
var
809
  S, C: TdSingle;
810
begin
811
  SinCos(Angle_, S, C);
812

813
  with Result do
814
  begin
815
    _11 := C;
816
    _12 := -S;
817
    _21 := +S;
818
    _22 := C;
819
  end
820
end;
821

822
function TdDoubleM2.GetM(const Y_, X_: Integer): TdDouble;
823
begin
824
  Result := _[Y_, X_];
825
end;
826

827
procedure TdDoubleM2.SetM(const Y_, X_: Integer; const M_: TdDouble);
828
begin
829
  _[Y_, X_] := M_;
830
end;
831

832
// ------------------------------------------------------------------------------
833

834
function TdDoubleM2.GetAxisX: TdDouble2D;
835
begin
836
  with Result do
837
  begin
838
    X := _11; { X := _12; }
839
    Y := _21; { Y := _22; }
840
  end;
841
end;
842

843
procedure TdDoubleM2.SetAxisX(const AxisX_: TdDouble2D);
844
begin
845
  with AxisX_ do
846
  begin
847
    _11 := X; { _12 := X; }
848
    _21 := Y; { _22 := Y; }
849
  end;
850
end;
851

852
function TdDoubleM2.GetAxisY: TdDouble2D;
853
begin
854
  with Result do
855
  begin
856
    { X := _11; } X := _12;
857
    { Y := _21; } Y := _22;
858
  end;
859
end;
860

861
procedure TdDoubleM2.SetAxisY(const AxisY_: TdDouble2D);
862
begin
863
  with AxisY_ do
864
  begin
865
    { _11 := X; } _12 := X;
866
    { _21 := Y; } _22 := Y;
867
  end;
868
end;
869

870
constructor TdDoubleM2.Create(const _11_, _12_, _21_, _22_: TdDouble);
871
begin
872
  _11 := _11_;
873
  _12 := _12_;
874
  _21 := _21_;
875
  _22 := _22_;
876
end;
877

878
class operator TdDoubleM2.Positive(const V_: TdDoubleM2): TdDoubleM2;
879
begin
880
  with Result do
881
  begin
882
    _11 := +V_._11;
883
    _12 := +V_._12;
884
    _21 := +V_._21;
885
    _22 := +V_._22;
886
  end
887
end;
888

889
class operator TdDoubleM2.Negative(const V_: TdDoubleM2): TdDoubleM2;
890
begin
891
  with Result do
892
  begin
893
    _11 := -V_._11;
894
    _12 := -V_._12;
895
    _21 := -V_._21;
896
    _22 := -V_._22;
897
  end
898
end;
899

900
class operator TdDoubleM2.Add(const A_, B_: TdDoubleM2): TdDoubleM2;
901
begin
902
  with Result do
903
  begin
904
    _11 := A_._11 + B_._11;
905
    _12 := A_._12 + B_._12;
906
    _21 := A_._21 + B_._21;
907
    _22 := A_._22 + B_._22;
908
  end
909
end;
910

911
class operator TdDoubleM2.Subtract(const A_, B_: TdDoubleM2): TdDoubleM2;
912
begin
913
  with Result do
914
  begin
915
    _11 := A_._11 - B_._11;
916
    _12 := A_._12 - B_._12;
917
    _21 := A_._21 - B_._21;
918
    _22 := A_._22 - B_._22;
919
  end
920
end;
921

922
class operator TdDoubleM2.Multiply(const A_, B_: TdDoubleM2): TdDoubleM2;
923
begin
924
  // _11 _12    _11 _12
925
  // _21 _22 × _21 _22
926

927
  with Result do
928
  begin
929
    _11 := A_._11 * B_._11 + A_._12 * B_._21;
930
    _12 := A_._11 * B_._12 + A_._12 * B_._22;
931

932
    _21 := A_._21 * B_._11 + A_._22 * B_._21;
933
    _22 := A_._21 * B_._12 + A_._22 * B_._22;
934
  end
935
end;
936

937
class operator TdDoubleM2.Multiply(const A_: TdDoubleM2; const B_: TdDouble)
938
  : TdDoubleM2;
939
begin
940
  with Result do
941
  begin
942
    _11 := A_._11 * B_;
943
    _12 := A_._12 * B_;
944
    _21 := A_._21 * B_;
945
    _22 := A_._22 * B_;
946
  end
947
end;
948

949
class operator TdDoubleM2.Multiply(const A_: TdDouble; const B_: TdDoubleM2)
950
  : TdDoubleM2;
951
begin
952
  with Result do
953
  begin
954
    _11 := A_ * B_._11;
955
    _12 := A_ * B_._12;
956
    _21 := A_ * B_._21;
957
    _22 := A_ * B_._22;
958
  end
959
end;
960

961
class operator TdDoubleM2.Multiply(const A_: TdDouble2D; const B_: TdDoubleM2)
962
  : TdDouble2D;
963
begin
964
  {
965
    _11 _12
966
    X Y × _21 _22
967
  }
968

969
  with Result do
970
  begin
971
    X := A_.X * B_._11 + A_.Y * B_._21;
972
    Y := A_.X * B_._12 + A_.Y * B_._22;
973
  end
974
end;
975

976
class operator TdDoubleM2.Multiply(const A_: TdDoubleM2; const B_: TdDouble2D)
977
  : TdDouble2D;
978
begin
979
  {
980
    _11 _12    X
981
    _21 _22 × Y
982
  }
983

984
  with Result do
985
  begin
986
    X := A_._11 * B_.X + A_._12 * B_.Y;
987
    Y := A_._21 * B_.X + A_._22 * B_.Y;
988
  end
989
end;
990

991
class operator TdDoubleM2.Divide(const A_: TdDoubleM2; const B_: TdDouble)
992
  : TdDoubleM2;
993
begin
994
  with Result do
995
  begin
996
    _11 := A_._11 / B_;
997
    _12 := A_._12 / B_;
998
    _21 := A_._21 / B_;
999
    _22 := A_._22 / B_;
1000
  end
1001
end;
1002

1003
function TdDoubleM2.Det: TdDouble;
1004
begin
1005
  Result := _11 * _22 - _21 * _12;
1006
end;
1007

1008
function TdDoubleM2.Adjugate: TdDoubleM2;
1009
begin
1010
  Result._11 := +_22;
1011
  Result._12 := -_12;
1012
  Result._21 := -_21;
1013
  Result._22 := +_11;
1014
end;
1015

1016
function TdDoubleM2.Inverse: TdDoubleM2;
1017
begin
1018
  Result := Adjugate / Det;
1019
end;
1020

1021
// ------------------------------------------------------------------------------
1022

1023
class function TdDoubleM2.Rotate(const Angle_: TdDouble): TdDoubleM2;
1024
var
1025
  S, C: TdDouble;
1026
begin
1027
  SinCos(Angle_, S, C);
1028

1029
  with Result do
1030
  begin
1031
    _11 := C;
1032
    _12 := -S;
1033
    _21 := +S;
1034
    _22 := C;
1035
  end
1036
end;
1037

1038
initialization // --------------------------------------------------------------
1039

1040
finalization
1041

1042
end.
1043