Luxophia

1
unit LUX.Matrix.L3;
2

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

5
uses LUX, LUX.D1, LUX.D2, LUX.D3, LUX.Matrix.L2;
6

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

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

11
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSingleM3
12

13
     TSingleM3 = record
14
     private
15
       ///// アクセス
16
       function GetM( const Y_,X_:Integer ) :Single;
17
       procedure SetM( const Y_,X_:Integer; const M_:Single );
18
       function GetAxisX :TSingle3D;
19
       procedure SetAxisX( const AxisX_:TSingle3D );
20
       function GetAxisY :TSingle3D;
21
       procedure SetAxisY( const AxisY_:TSingle3D );
22
       function GetAxisZ :TSingle3D;
23
       procedure SetAxisZ( const AxisZ_:TSingle3D );
24
       function GetSum :Single;
25
     public
26
       constructor Create( const _11_,_12_,_13_,
27
                                 _21_,_22_,_23_,
28
                                 _31_,_32_,_33_:Single );
29
       ///// プロパティ
30
       property M[ const Y_,X_:Integer ] :Single    read GetM     write SetM    ; default;
31
       property AxisX                    :TSingle3D read GetAxisX write SetAxisX;
32
       property AxisY                    :TSingle3D read GetAxisY write SetAxisY;
33
       property AxisZ                    :TSingle3D read GetAxisZ write SetAxisZ;
34
       property Sum                      :Single    read GetSum;
35
       ///// 演算子
36
       class operator Negative( const V_:TSingleM3 ) :TSingleM3;
37
       class operator Positive( const V_:TSingleM3 ) :TSingleM3;
38
       class operator Add( const A_,B_:TSingleM3 ) :TSingleM3;
39
       class operator Subtract( const A_,B_:TSingleM3 ) :TSingleM3;
40
       class operator Multiply( const A_,B_:TSingleM3 ) :TSingleM3;
41
       class operator Multiply( const A_:TSingleM3; const B_:Single ) :TSingleM3;
42
       class operator Multiply( const A_:Single; const B_:TSingleM3 ) :TSingleM3;
43
       class operator Multiply( const A_:TSingle3D; const B_:TSingleM3 ) :TSingle3D;
44
       class operator Multiply( const A_:TSingleM3; const B_:TSingle3D ) :TSingle3D;
45
       class operator Divide( const A_:TSingleM3; const B_:Single ) :TSingleM3;
46
       ///// メソッド
47
       function Transpose :TSingleM3;
48
       function Det :Single;
49
       function Adjugate :TSingleM3;
50
       function Inverse :TSingleM3;
51

52
     case Integer of
53
      0:( _ :array [ 1..3, 1..3 ] of Single; );
54
      1:( _11, _12, _13,
55
          _21, _22, _23,
56
          _31, _32, _33 :Single;             );
57
     end;
58

59
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleM3
60

61
     TDoubleM3 = record
62
     private
63
       ///// アクセス
64
       function GetM( const Y_,X_:Integer ) :Double;
65
       procedure SetM( const Y_,X_:Integer; const M_:Double );
66
       function GetAxisX :TDouble3D;
67
       procedure SetAxisX( const AxisX_:TDouble3D );
68
       function GetAxisY :TDouble3D;
69
       procedure SetAxisY( const AxisY_:TDouble3D );
70
       function GetAxisZ :TDouble3D;
71
       procedure SetAxisZ( const AxisZ_:TDouble3D );
72
     public
73
       constructor Create( const _11_,_12_,_13_,
74
                                 _21_,_22_,_23_,
75
                                 _31_,_32_,_33_:Double );
76
       ///// プロパティ
77
       property M[ const Y_,X_:Integer ] :Double    read GetM     write SetM    ; default;
78
       property AxisX                    :TDouble3D read GetAxisX write SetAxisX;
79
       property AxisY                    :TDouble3D read GetAxisY write SetAxisY;
80
       property AxisZ                    :TDouble3D read GetAxisZ write SetAxisZ;
81
       ///// 演算子
82
       class operator Negative( const V_:TDoubleM3 ) :TDoubleM3;
83
       class operator Positive( const V_:TDoubleM3 ) :TDoubleM3;
84
       class operator Add( const A_,B_:TDoubleM3 ) :TDoubleM3;
85
       class operator Subtract( const A_,B_:TDoubleM3 ) :TDoubleM3;
86
       class operator Multiply( const A_,B_:TDoubleM3 ) :TDoubleM3;
87
       class operator Multiply( const A_:TDoubleM3; const B_:Double ) :TDoubleM3;
88
       class operator Multiply( const A_:Double; const B_:TDoubleM3 ) :TDoubleM3;
89
       class operator Multiply( const A_:TDouble3D; const B_:TDoubleM3 ) :TDouble3D;
90
       class operator Multiply( const A_:TDoubleM3; const B_:TDouble3D ) :TDouble3D;
91
       class operator Divide( const A_:TDoubleM3; const B_:Double ) :TDoubleM3;
92
       ///// メソッド
93
       function Transpose :TDoubleM3;
94
       function Det :Double;
95
       function Adjugate :TDoubleM3;
96
       function Inverse :TDoubleM3;
97

98
     case Integer of
99
      0:( _ :array [ 1..3, 1..3 ] of Double; );
100
      1:( _11, _12, _13,
101
          _21, _22, _23,
102
          _31, _32, _33 :Double;             );
103
     end;
104

105
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdSingleM3
106

107
     TdSingleM3 = record
108
     private
109
       ///// アクセス
110
       function GetM( const Y_,X_:Integer ) :TdSingle;
111
       procedure SetM( const Y_,X_:Integer; const M_:TdSingle );
112
       function GetAxisX :TdSingle3D;
113
       procedure SetAxisX( const AxisX_:TdSingle3D );
114
       function GetAxisY :TdSingle3D;
115
       procedure SetAxisY( const AxisY_:TdSingle3D );
116
       function GetAxisZ :TdSingle3D;
117
       procedure SetAxisZ( const AxisZ_:TdSingle3D );
118
       function GetSum :TdSingle;
119
     public
120
       constructor Create( const _11_,_12_,_13_,
121
                                 _21_,_22_,_23_,
122
                                 _31_,_32_,_33_:TdSingle );
123
       ///// プロパティ
124
       property M[ const Y_,X_:Integer ] :TdSingle   read GetM     write SetM    ; default;
125
       property AxisX                    :TdSingle3D read GetAxisX write SetAxisX;
126
       property AxisY                    :TdSingle3D read GetAxisY write SetAxisY;
127
       property AxisZ                    :TdSingle3D read GetAxisZ write SetAxisZ;
128
       property Sum   :TdSingle    read GetSum;
129
       ///// 演算子
130
       class operator Negative( const V_:TdSingleM3 ) :TdSingleM3;
131
       class operator Positive( const V_:TdSingleM3 ) :TdSingleM3;
132
       class operator Add( const A_,B_:TdSingleM3 ) :TdSingleM3;
133
       class operator Subtract( const A_,B_:TdSingleM3 ) :TdSingleM3;
134
       class operator Multiply( const A_,B_:TdSingleM3 ) :TdSingleM3;
135
       class operator Multiply( const A_:TdSingleM3; const B_:TdSingle ) :TdSingleM3;
136
       class operator Multiply( const A_:TdSingle; const B_:TdSingleM3 ) :TdSingleM3;
137
       class operator Multiply( const A_:TdSingle3D; const B_:TdSingleM3 ) :TdSingle3D;
138
       class operator Multiply( const A_:TdSingleM3; const B_:TdSingle3D ) :TdSingle3D;
139
       class operator Divide( const A_:TdSingleM3; const B_:TdSingle ) :TdSingleM3;
140
       ///// メソッド
141
       function Transpose :TdSingleM3;
142
       function Det :TdSingle;
143
       function Adjugate :TdSingleM3;
144
       function Inverse :TdSingleM3;
145

146
     case Integer of
147
      0:( _ :array [ 1..3, 1..3 ] of TdSingle; );
148
      1:( _11, _12, _13,
149
          _21, _22, _23,
150
          _31, _32, _33 :TdSingle;             );
151
     end;
152

153
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdDoubleM3
154

155
     TdDoubleM3 = record
156
     private
157
       ///// アクセス
158
       function GetM( const Y_,X_:Integer ) :TdDouble;
159
       procedure SetM( const Y_,X_:Integer; const M_:TdDouble );
160
       function GetAxisX :TdDouble3D;
161
       procedure SetAxisX( const AxisX_:TdDouble3D );
162
       function GetAxisY :TdDouble3D;
163
       procedure SetAxisY( const AxisY_:TdDouble3D );
164
       function GetAxisZ :TdDouble3D;
165
       procedure SetAxisZ( const AxisZ_:TdDouble3D );
166
     public
167
       constructor Create( const _11_,_12_,_13_,
168
                                 _21_,_22_,_23_,
169
                                 _31_,_32_,_33_:TdDouble );
170
       ///// プロパティ
171
       property M[ const Y_,X_:Integer ] :TdDouble   read GetM     write SetM    ; default;
172
       property AxisX                    :TdDouble3D read GetAxisX write SetAxisX;
173
       property AxisY                    :TdDouble3D read GetAxisY write SetAxisY;
174
       property AxisZ                    :TdDouble3D read GetAxisZ write SetAxisZ;
175
       ///// 演算子
176
       class operator Negative( const V_:TdDoubleM3 ) :TdDoubleM3;
177
       class operator Positive( const V_:TdDoubleM3 ) :TdDoubleM3;
178
       class operator Add( const A_,B_:TdDoubleM3 ) :TdDoubleM3;
179
       class operator Subtract( const A_,B_:TdDoubleM3 ) :TdDoubleM3;
180
       class operator Multiply( const A_,B_:TdDoubleM3 ) :TdDoubleM3;
181
       class operator Multiply( const A_:TdDoubleM3; const B_:TdDouble ) :TdDoubleM3;
182
       class operator Multiply( const A_:TdDouble; const B_:TdDoubleM3 ) :TdDoubleM3;
183
       class operator Multiply( const A_:TdDouble3D; const B_:TdDoubleM3 ) :TdDouble3D;
184
       class operator Multiply( const A_:TdDoubleM3; const B_:TdDouble3D ) :TdDouble3D;
185
       class operator Divide( const A_:TdDoubleM3; const B_:TdDouble ) :TdDoubleM3;
186
       ///// メソッド
187
       function Transpose :TdDoubleM3;
188
       function Det :TdDouble;
189
       function Adjugate :TdDoubleM3;
190
       function Inverse :TdDoubleM3;
191

192
     case Integer of
193
      0:( _ :array [ 1..3, 1..3 ] of TdDouble; );
194
      1:( _11, _12, _13,
195
          _21, _22, _23,
196
          _31, _32, _33 :TdDouble;             );
197
     end;
198

199
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
200

201
//const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
202

203
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
204

205
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
206

207
implementation //############################################################### ■
208

209
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
210

211
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSingleM3
212

213
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
214

215
/////////////////////////////////////////////////////////////////////// アクセス
216

217
function TSingleM3.GetM( const Y_,X_:Integer ) :Single;
218
begin
219
     Result := _[ Y_, X_ ];
220
end;
221

222
procedure TSingleM3.SetM( const Y_,X_:Integer; const M_:Single );
223
begin
224
     _[ Y_, X_ ] := M_;
225
end;
226

227
//------------------------------------------------------------------------------
228

229
function TSingleM3.GetAxisX :TSingle3D;
230
begin
231
     with Result do
232
     begin
233
          X := _11;
234
          Y := _21;
235
          Z := _31;
236
     end;
237
end;
238

239
procedure TSingleM3.SetAxisX( const AxisX_:TSingle3D );
240
begin
241
     with AxisX_ do
242
     begin
243
          _11 := X;
244
          _21 := Y;
245
          _31 := Z;
246
     end;
247
end;
248

249
function TSingleM3.GetAxisY :TSingle3D;
250
begin
251
     with Result do
252
     begin
253
          X := _12;
254
          Y := _22;
255
          Z := _32;
256
     end;
257
end;
258

259
procedure TSingleM3.SetAxisY( const AxisY_:TSingle3D );
260
begin
261
     with AxisY_ do
262
     begin
263
          _12 := X;
264
          _22 := Y;
265
          _32 := Z;
266
     end;
267
end;
268

269
function TSingleM3.GetAxisZ :TSingle3D;
270
begin
271
     with Result do
272
     begin
273
          X := _13;
274
          Y := _23;
275
          Z := _33;
276
     end;
277
end;
278

279
procedure TSingleM3.SetAxisZ( const AxisZ_:TSingle3D );
280
begin
281
     with AxisZ_ do
282
     begin
283
          _13 := X;
284
          _23 := Y;
285
          _33 := Z;
286
     end;
287
end;
288

289
function TSingleM3.GetSum :Single;
290
begin
291
     Result := _11 + _12 + _13
292
             + _21 + _22 + _23
293
             + _31 + _32 + _33;
294
end;
295

296
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
297

298
constructor TSingleM3.Create( const _11_,_12_,_13_,
299
                                    _21_,_22_,_23_,
300
                                    _31_,_32_,_33_:Single );
301
begin
302
     _11 := _11_;  _12 := _12_;  _13 := _13_;
303
     _21 := _21_;  _22 := _22_;  _23 := _23_;
304
     _31 := _31_;  _32 := _32_;  _33 := _33_;
305
end;
306

307
///////////////////////////////////////////////////////////////////////// 演算子
308

309
class operator TSingleM3.Positive( const V_:TSingleM3 ) :TSingleM3;
310
begin
311
     with Result do
312
     begin
313
          _11 := +V_._11;  _12 := +V_._12;  _13 := +V_._13;
314
          _21 := +V_._21;  _22 := +V_._22;  _23 := +V_._23;
315
          _31 := +V_._31;  _32 := +V_._32;  _33 := +V_._33;
316
     end;
317
end;
318

319
class operator TSingleM3.Negative( const V_:TSingleM3 ) :TSingleM3;
320
begin
321
     with Result do
322
     begin
323
          _11 := -V_._11;  _12 := -V_._12;  _13 := -V_._13;
324
          _21 := -V_._21;  _22 := -V_._22;  _23 := -V_._23;
325
          _31 := -V_._31;  _32 := -V_._32;  _33 := -V_._33;
326
     end;
327
end;
328

329
class operator TSingleM3.Add( const A_,B_:TSingleM3 ) :TSingleM3;
330
begin
331
     with Result do
332
     begin
333
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;  _13 := A_._13 + B_._13;
334
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;  _23 := A_._23 + B_._23;
335
          _31 := A_._31 + B_._31;  _32 := A_._32 + B_._32;  _33 := A_._33 + B_._33;
336
     end;
337
end;
338

339
class operator TSingleM3.Subtract( const A_,B_:TSingleM3 ) :TSingleM3;
340
begin
341
     with Result do
342
     begin
343
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;  _13 := A_._13 - B_._13;
344
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;  _23 := A_._23 - B_._23;
345
          _31 := A_._31 - B_._31;  _32 := A_._32 - B_._32;  _33 := A_._33 - B_._33;
346
     end;
347
end;
348

349
class operator TSingleM3.Multiply( const A_,B_:TSingleM3 ) :TSingleM3;
350
begin
351
     {
352
       11 12 13    11 12 13
353
       21 22 23 × 21 22 23
354
       31 32 33    31 32 33
355
     }
356

357
     with Result do
358
     begin
359
          _11 := A_._11 * B_._11 + A_._12 * B_._21 + A_._13 * B_._31;
360
          _12 := A_._11 * B_._12 + A_._12 * B_._22 + A_._13 * B_._32;
361
          _13 := A_._11 * B_._13 + A_._12 * B_._23 + A_._13 * B_._33;
362

363
          _21 := A_._21 * B_._11 + A_._22 * B_._21 + A_._23 * B_._31;
364
          _22 := A_._21 * B_._12 + A_._22 * B_._22 + A_._23 * B_._32;
365
          _23 := A_._21 * B_._13 + A_._22 * B_._23 + A_._23 * B_._33;
366

367
          _31 := A_._31 * B_._11 + A_._32 * B_._21 + A_._33 * B_._31;
368
          _32 := A_._31 * B_._12 + A_._32 * B_._22 + A_._33 * B_._32;
369
          _33 := A_._31 * B_._13 + A_._32 * B_._23 + A_._33 * B_._33;
370
     end;
371
end;
372

373
class operator TSingleM3.Multiply( const A_:TSingleM3; const B_:Single ) :TSingleM3;
374
begin
375
     with Result do
376
     begin
377
          _11 := A_._11 * B_;  _12 := A_._12 * B_;  _13 := A_._13 * B_;
378
          _21 := A_._21 * B_;  _22 := A_._22 * B_;  _23 := A_._23 * B_;
379
          _31 := A_._31 * B_;  _32 := A_._32 * B_;  _33 := A_._33 * B_;
380
     end;
381
end;
382

383
class operator TSingleM3.Multiply( const A_:Single; const B_:TSingleM3 ) :TSingleM3;
384
begin
385
     with Result do
386
     begin
387
          _11 := A_ * B_._11;  _12 := A_ * B_._12;  _13 := A_ * B_._13;
388
          _21 := A_ * B_._21;  _22 := A_ * B_._22;  _23 := A_ * B_._23;
389
          _31 := A_ * B_._31;  _32 := A_ * B_._32;  _33 := A_ * B_._33;
390
     end;
391
end;
392

393
class operator TSingleM3.Multiply( const A_:TSingle3D; const B_:TSingleM3 ) :TSingle3D;
394
begin
395
     {
396
                11 12 13
397
       X Y Z × 21 22 23
398
                31 32 33
399
     }
400

401
     with Result do
402
     begin
403
          X := A_.X * B_._11 + A_.Y * B_._21 + A_.Z * B_._31;
404
          Y := A_.X * B_._12 + A_.Y * B_._22 + A_.Z * B_._32;
405
          Z := A_.X * B_._13 + A_.Y * B_._23 + A_.Z * B_._33;
406
     end;
407
end;
408

409
class operator TSingleM3.Multiply( const A_:TSingleM3; const B_:TSingle3D ) :TSingle3D;
410
begin
411
     {
412
       11 12 13    X
413
       21 22 23 × Y
414
       31 32 33    Z
415
     }
416

417
     with Result do
418
     begin
419
          X := A_._11 * B_.X + A_._12 * B_.Y + A_._13 * B_.Z;
420
          Y := A_._21 * B_.X + A_._22 * B_.Y + A_._23 * B_.Z;
421
          Z := A_._31 * B_.X + A_._32 * B_.Y + A_._33 * B_.Z;
422
     end;
423
end;
424

425
class operator TSingleM3.Divide( const A_:TSingleM3; const B_:Single ) :TSingleM3;
426
begin
427
     with Result do
428
     begin
429
          _11 := A_._11 / B_;  _12 := A_._12 / B_;  _13 := A_._13 / B_;
430
          _21 := A_._21 / B_;  _22 := A_._22 / B_;  _23 := A_._23 / B_;
431
          _31 := A_._31 / B_;  _32 := A_._32 / B_;  _33 := A_._33 / B_;
432
     end;
433
end;
434

435
/////////////////////////////////////////////////////////////////////// メソッド
436

437
function TSingleM3.Transpose :TSingleM3;
438
begin
439
     Result._11 := _11;  Result._12 := _21;  Result._13 := _31;
440
     Result._21 := _12;  Result._22 := _22;  Result._23 := _32;
441
     Result._31 := _13;  Result._32 := _23;  Result._33 := _33;
442
end;
443

444
function TSingleM3.Det :Single;
445
begin
446
     Result:= _11 * ( _22 * _33 - _23 * _32 )
447
            + _12 * ( _23 * _31 - _21 * _33 )
448
            + _13 * ( _21 * _32 - _22 * _31 );
449
end;
450

451
function TSingleM3.Adjugate :TSingleM3;
452
begin
453
     Result._11 := +TSingleM2.Create( {11} {12} {13}
454
                                      {21} _22, _23,
455
                                      {31} _32, _33  ).Det;
456

457
     Result._21 := -TSingleM2.Create( {11} {12} {13}
458
                                      _21, {22} _23,
459
                                      _31, {32} _33  ).Det;
460

461
     Result._31 := +TSingleM2.Create( {11} {12} {13}
462
                                      _21, _22, {23}
463
                                      _31, _32  {33} ).Det;
464

465
     Result._12 := -TSingleM2.Create( {11} _12, _13,
466
                                      {21} {22} {23}
467
                                      {31} _32, _33  ).Det;
468

469
     Result._22 := +TSingleM2.Create( _11, {12} _13,
470
                                      {21} {22} {23}
471
                                      _31, {32} _33  ).Det;
472

473
     Result._32 := -TSingleM2.Create( _11, _12, {13}
474
                                      {21} {22} {23}
475
                                      _31, _32  {33} ).Det;
476

477
     Result._13 := +TSingleM2.Create( {11} _12, _13,
478
                                      {21} _22, _23
479
                                      {31} {32} {33} ).Det;
480

481
     Result._23 := -TSingleM2.Create( _11, {12} _13,
482
                                      _21, {22} _23
483
                                      {31} {32} {33} ).Det;
484

485
     Result._33 := +TSingleM2.Create( _11, _12, {13}
486
                                      _21, _22  {23}
487
                                      {31} {32} {33} ).Det;
488
end;
489

490
function TSingleM3.Inverse :TSingleM3;
491
var
492
   A :TSingleM3;
493
begin
494
     A := Adjugate;
495

496
     Result := A / ( _11 * A._11
497
                   + _12 * A._21
498
                   + _13 * A._31 );
499
end;
500

501
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleM3
502

503
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
504

505
/////////////////////////////////////////////////////////////////////// アクセス
506

507
function TDoubleM3.GetM( const Y_,X_:Integer ) :Double;
508
begin
509
     Result := _[ Y_, X_ ];
510
end;
511

512
procedure TDoubleM3.SetM( const Y_,X_:Integer; const M_:Double );
513
begin
514
     _[ Y_, X_ ] := M_;
515
end;
516

517
//------------------------------------------------------------------------------
518

519
function TDoubleM3.GetAxisX :TDouble3D;
520
begin
521
     with Result do
522
     begin
523
          X := _11;
524
          Y := _21;
525
          Z := _31;
526
     end;
527
end;
528

529
procedure TDoubleM3.SetAxisX( const AxisX_:TDouble3D );
530
begin
531
     with AxisX_ do
532
     begin
533
          _11 := X;
534
          _21 := Y;
535
          _31 := Z;
536
     end;
537
end;
538

539
function TDoubleM3.GetAxisY :TDouble3D;
540
begin
541
     with Result do
542
     begin
543
          X := _12;
544
          Y := _22;
545
          Z := _32;
546
     end;
547
end;
548

549
procedure TDoubleM3.SetAxisY( const AxisY_:TDouble3D );
550
begin
551
     with AxisY_ do
552
     begin
553
          _12 := X;
554
          _22 := Y;
555
          _32 := Z;
556
     end;
557
end;
558

559
function TDoubleM3.GetAxisZ :TDouble3D;
560
begin
561
     with Result do
562
     begin
563
          X := _13;
564
          Y := _23;
565
          Z := _33;
566
     end;
567
end;
568

569
procedure TDoubleM3.SetAxisZ( const AxisZ_:TDouble3D );
570
begin
571
     with AxisZ_ do
572
     begin
573
          _13 := X;
574
          _23 := Y;
575
          _33 := Z;
576
     end;
577
end;
578

579
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
580

581
constructor TDoubleM3.Create( const _11_,_12_,_13_,
582
                                    _21_,_22_,_23_,
583
                                    _31_,_32_,_33_:Double );
584
begin
585
     _11 := _11_;  _12 := _12_;  _13 := _13_;
586
     _21 := _21_;  _22 := _22_;  _23 := _23_;
587
     _31 := _31_;  _32 := _32_;  _33 := _33_;
588
end;
589

590
///////////////////////////////////////////////////////////////////////// 演算子
591

592
class operator TDoubleM3.Positive( const V_:TDoubleM3 ) :TDoubleM3;
593
begin
594
     with Result do
595
     begin
596
          _11 := +V_._11;  _12 := +V_._12;  _13 := +V_._13;
597
          _21 := +V_._21;  _22 := +V_._22;  _23 := +V_._23;
598
          _31 := +V_._31;  _32 := +V_._32;  _33 := +V_._33;
599
     end;
600
end;
601

602
class operator TDoubleM3.Negative( const V_:TDoubleM3 ) :TDoubleM3;
603
begin
604
     with Result do
605
     begin
606
          _11 := -V_._11;  _12 := -V_._12;  _13 := -V_._13;
607
          _21 := -V_._21;  _22 := -V_._22;  _23 := -V_._23;
608
          _31 := -V_._31;  _32 := -V_._32;  _33 := -V_._33;
609
     end;
610
end;
611

612
class operator TDoubleM3.Add( const A_,B_:TDoubleM3 ) :TDoubleM3;
613
begin
614
     with Result do
615
     begin
616
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;  _13 := A_._13 + B_._13;
617
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;  _23 := A_._23 + B_._23;
618
          _31 := A_._31 + B_._31;  _32 := A_._32 + B_._32;  _33 := A_._33 + B_._33;
619
     end;
620
end;
621

622
class operator TDoubleM3.Subtract( const A_,B_:TDoubleM3 ) :TDoubleM3;
623
begin
624
     with Result do
625
     begin
626
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;  _13 := A_._13 - B_._13;
627
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;  _23 := A_._23 - B_._23;
628
          _31 := A_._31 - B_._31;  _32 := A_._32 - B_._32;  _33 := A_._33 - B_._33;
629
     end;
630
end;
631

632
class operator TDoubleM3.Multiply( const A_,B_:TDoubleM3 ) :TDoubleM3;
633
begin
634
     {
635
       11 12 13    11 12 13
636
       21 22 23 × 21 22 23
637
       31 32 33    31 32 33
638
     }
639

640
     with Result do
641
     begin
642
          _11 := A_._11 * B_._11 + A_._12 * B_._21 + A_._13 * B_._31;
643
          _12 := A_._11 * B_._12 + A_._12 * B_._22 + A_._13 * B_._32;
644
          _13 := A_._11 * B_._13 + A_._12 * B_._23 + A_._13 * B_._33;
645

646
          _21 := A_._21 * B_._11 + A_._22 * B_._21 + A_._23 * B_._31;
647
          _22 := A_._21 * B_._12 + A_._22 * B_._22 + A_._23 * B_._32;
648
          _23 := A_._21 * B_._13 + A_._22 * B_._23 + A_._23 * B_._33;
649

650
          _31 := A_._31 * B_._11 + A_._32 * B_._21 + A_._33 * B_._31;
651
          _32 := A_._31 * B_._12 + A_._32 * B_._22 + A_._33 * B_._32;
652
          _33 := A_._31 * B_._13 + A_._32 * B_._23 + A_._33 * B_._33;
653
     end;
654
end;
655

656
class operator TDoubleM3.Multiply( const A_:TDoubleM3; const B_:Double ) :TDoubleM3;
657
begin
658
     with Result do
659
     begin
660
          _11 := A_._11 * B_;  _12 := A_._12 * B_;  _13 := A_._13 * B_;
661
          _21 := A_._21 * B_;  _22 := A_._22 * B_;  _23 := A_._23 * B_;
662
          _31 := A_._31 * B_;  _32 := A_._32 * B_;  _33 := A_._33 * B_;
663
     end;
664
end;
665

666
class operator TDoubleM3.Multiply( const A_:Double; const B_:TDoubleM3 ) :TDoubleM3;
667
begin
668
     with Result do
669
     begin
670
          _11 := A_ * B_._11;  _12 := A_ * B_._12;  _13 := A_ * B_._13;
671
          _21 := A_ * B_._21;  _22 := A_ * B_._22;  _23 := A_ * B_._23;
672
          _31 := A_ * B_._31;  _32 := A_ * B_._32;  _33 := A_ * B_._33;
673
     end;
674
end;
675

676
class operator TDoubleM3.Multiply( const A_:TDouble3D; const B_:TDoubleM3 ) :TDouble3D;
677
begin
678
     {
679
                11 12 13
680
       X Y Z × 21 22 23
681
                31 32 33
682
     }
683

684
     with Result do
685
     begin
686
          X := A_.X * B_._11 + A_.Y * B_._21 + A_.Z * B_._31;
687
          Y := A_.X * B_._12 + A_.Y * B_._22 + A_.Z * B_._32;
688
          Z := A_.X * B_._13 + A_.Y * B_._23 + A_.Z * B_._33;
689
     end;
690
end;
691

692
class operator TDoubleM3.Multiply( const A_:TDoubleM3; const B_:TDouble3D ) :TDouble3D;
693
begin
694
     {
695
       11 12 13    X
696
       21 22 23 × Y
697
       31 32 33    Z
698
     }
699

700
     with Result do
701
     begin
702
          X := A_._11 * B_.X + A_._12 * B_.Y + A_._13 * B_.Z;
703
          Y := A_._21 * B_.X + A_._22 * B_.Y + A_._23 * B_.Z;
704
          Z := A_._31 * B_.X + A_._32 * B_.Y + A_._33 * B_.Z;
705
     end;
706
end;
707

708
class operator TDoubleM3.Divide( const A_:TDoubleM3; const B_:Double ) :TDoubleM3;
709
begin
710
     with Result do
711
     begin
712
          _11 := A_._11 / B_;  _12 := A_._12 / B_;  _13 := A_._13 / B_;
713
          _21 := A_._21 / B_;  _22 := A_._22 / B_;  _23 := A_._23 / B_;
714
          _31 := A_._31 / B_;  _32 := A_._32 / B_;  _33 := A_._33 / B_;
715
     end;
716
end;
717

718
/////////////////////////////////////////////////////////////////////// メソッド
719

720
function TDoubleM3.Transpose :TDoubleM3;
721
begin
722
     Result._11 := _11;  Result._12 := _21;  Result._13 := _31;
723
     Result._21 := _12;  Result._22 := _22;  Result._23 := _32;
724
     Result._31 := _13;  Result._32 := _23;  Result._33 := _33;
725
end;
726

727
function TDoubleM3.Det :Double;
728
begin
729
     Result:= _11 * ( _22 * _33 - _23 * _32 )
730
            + _12 * ( _23 * _31 - _21 * _33 )
731
            + _13 * ( _21 * _32 - _22 * _31 );
732
end;
733

734
function TDoubleM3.Adjugate :TDoubleM3;
735
begin
736
     Result._11 := +TDoubleM2.Create( {11} {12} {13}
737
                                      {21} _22, _23,
738
                                      {31} _32, _33  ).Det;
739

740
     Result._21 := -TDoubleM2.Create( {11} {12} {13}
741
                                      _21, {22} _23,
742
                                      _31, {32} _33  ).Det;
743

744
     Result._31 := +TDoubleM2.Create( {11} {12} {13}
745
                                      _21, _22, {23}
746
                                      _31, _32  {33} ).Det;
747

748
     Result._12 := -TDoubleM2.Create( {11} _12, _13,
749
                                      {21} {22} {23}
750
                                      {31} _32, _33  ).Det;
751

752
     Result._22 := +TDoubleM2.Create( _11, {12} _13,
753
                                      {21} {22} {23}
754
                                      _31, {32} _33  ).Det;
755

756
     Result._32 := -TDoubleM2.Create( _11, _12, {13}
757
                                      {21} {22} {23}
758
                                      _31, _32  {33} ).Det;
759

760
     Result._13 := +TDoubleM2.Create( {11} _12, _13,
761
                                      {21} _22, _23
762
                                      {31} {32} {33} ).Det;
763

764
     Result._23 := -TDoubleM2.Create( _11, {12} _13,
765
                                      _21, {22} _23
766
                                      {31} {32} {33} ).Det;
767

768
     Result._33 := +TDoubleM2.Create( _11, _12, {13}
769
                                      _21, _22  {23}
770
                                      {31} {32} {33} ).Det;
771
end;
772

773
function TDoubleM3.Inverse :TDoubleM3;
774
var
775
   A :TDoubleM3;
776
begin
777
     A := Adjugate;
778

779
     Result := A / ( _11 * A._11
780
                   + _12 * A._21
781
                   + _13 * A._31 );
782
end;
783

784

785
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdSingleM3
786

787
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
788

789
/////////////////////////////////////////////////////////////////////// アクセス
790

791
function TdSingleM3.GetM( const Y_,X_:Integer ) :TdSingle;
792
begin
793
     Result := _[ Y_, X_ ];
794
end;
795

796
procedure TdSingleM3.SetM( const Y_,X_:Integer; const M_:TdSingle );
797
begin
798
     _[ Y_, X_ ] := M_;
799
end;
800

801
//------------------------------------------------------------------------------
802

803
function TdSingleM3.GetAxisX :TdSingle3D;
804
begin
805
     with Result do
806
     begin
807
          X := _11;
808
          Y := _21;
809
          Z := _31;
810
     end;
811
end;
812

813
procedure TdSingleM3.SetAxisX( const AxisX_:TdSingle3D );
814
begin
815
     with AxisX_ do
816
     begin
817
          _11 := X;
818
          _21 := Y;
819
          _31 := Z;
820
     end;
821
end;
822

823
function TdSingleM3.GetAxisY :TdSingle3D;
824
begin
825
     with Result do
826
     begin
827
          X := _12;
828
          Y := _22;
829
          Z := _32;
830
     end;
831
end;
832

833
procedure TdSingleM3.SetAxisY( const AxisY_:TdSingle3D );
834
begin
835
     with AxisY_ do
836
     begin
837
          _12 := X;
838
          _22 := Y;
839
          _32 := Z;
840
     end;
841
end;
842

843
function TdSingleM3.GetAxisZ :TdSingle3D;
844
begin
845
     with Result do
846
     begin
847
          X := _13;
848
          Y := _23;
849
          Z := _33;
850
     end;
851
end;
852

853
procedure TdSingleM3.SetAxisZ( const AxisZ_:TdSingle3D );
854
begin
855
     with AxisZ_ do
856
     begin
857
          _13 := X;
858
          _23 := Y;
859
          _33 := Z;
860
     end;
861
end;
862

863
function TdSingleM3.GetSum :TdSingle;
864
begin
865
     Result := _11 + _12 + _13
866
             + _21 + _22 + _23
867
             + _31 + _32 + _33;
868
end;
869

870
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
871

872
constructor TdSingleM3.Create( const _11_,_12_,_13_,
873
                                     _21_,_22_,_23_,
874
                                     _31_,_32_,_33_:TdSingle );
875
begin
876
     _11 := _11_;  _12 := _12_;  _13 := _13_;
877
     _21 := _21_;  _22 := _22_;  _23 := _23_;
878
     _31 := _31_;  _32 := _32_;  _33 := _33_;
879
end;
880

881
///////////////////////////////////////////////////////////////////////// 演算子
882

883
class operator TdSingleM3.Positive( const V_:TdSingleM3 ) :TdSingleM3;
884
begin
885
     with Result do
886
     begin
887
          _11 := +V_._11;  _12 := +V_._12;  _13 := +V_._13;
888
          _21 := +V_._21;  _22 := +V_._22;  _23 := +V_._23;
889
          _31 := +V_._31;  _32 := +V_._32;  _33 := +V_._33;
890
     end;
891
end;
892

893
class operator TdSingleM3.Negative( const V_:TdSingleM3 ) :TdSingleM3;
894
begin
895
     with Result do
896
     begin
897
          _11 := -V_._11;  _12 := -V_._12;  _13 := -V_._13;
898
          _21 := -V_._21;  _22 := -V_._22;  _23 := -V_._23;
899
          _31 := -V_._31;  _32 := -V_._32;  _33 := -V_._33;
900
     end;
901
end;
902

903
class operator TdSingleM3.Add( const A_,B_:TdSingleM3 ) :TdSingleM3;
904
begin
905
     with Result do
906
     begin
907
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;  _13 := A_._13 + B_._13;
908
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;  _23 := A_._23 + B_._23;
909
          _31 := A_._31 + B_._31;  _32 := A_._32 + B_._32;  _33 := A_._33 + B_._33;
910
     end;
911
end;
912

913
class operator TdSingleM3.Subtract( const A_,B_:TdSingleM3 ) :TdSingleM3;
914
begin
915
     with Result do
916
     begin
917
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;  _13 := A_._13 - B_._13;
918
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;  _23 := A_._23 - B_._23;
919
          _31 := A_._31 - B_._31;  _32 := A_._32 - B_._32;  _33 := A_._33 - B_._33;
920
     end;
921
end;
922

923
class operator TdSingleM3.Multiply( const A_,B_:TdSingleM3 ) :TdSingleM3;
924
begin
925
     {
926
       11 12 13    11 12 13
927
       21 22 23 × 21 22 23
928
       31 32 33    31 32 33
929
     }
930

931
     with Result do
932
     begin
933
          _11 := A_._11 * B_._11 + A_._12 * B_._21 + A_._13 * B_._31;
934
          _12 := A_._11 * B_._12 + A_._12 * B_._22 + A_._13 * B_._32;
935
          _13 := A_._11 * B_._13 + A_._12 * B_._23 + A_._13 * B_._33;
936

937
          _21 := A_._21 * B_._11 + A_._22 * B_._21 + A_._23 * B_._31;
938
          _22 := A_._21 * B_._12 + A_._22 * B_._22 + A_._23 * B_._32;
939
          _23 := A_._21 * B_._13 + A_._22 * B_._23 + A_._23 * B_._33;
940

941
          _31 := A_._31 * B_._11 + A_._32 * B_._21 + A_._33 * B_._31;
942
          _32 := A_._31 * B_._12 + A_._32 * B_._22 + A_._33 * B_._32;
943
          _33 := A_._31 * B_._13 + A_._32 * B_._23 + A_._33 * B_._33;
944
     end;
945
end;
946

947
class operator TdSingleM3.Multiply( const A_:TdSingleM3; const B_:TdSingle ) :TdSingleM3;
948
begin
949
     with Result do
950
     begin
951
          _11 := A_._11 * B_;  _12 := A_._12 * B_;  _13 := A_._13 * B_;
952
          _21 := A_._21 * B_;  _22 := A_._22 * B_;  _23 := A_._23 * B_;
953
          _31 := A_._31 * B_;  _32 := A_._32 * B_;  _33 := A_._33 * B_;
954
     end;
955
end;
956

957
class operator TdSingleM3.Multiply( const A_:TdSingle; const B_:TdSingleM3 ) :TdSingleM3;
958
begin
959
     with Result do
960
     begin
961
          _11 := A_ * B_._11;  _12 := A_ * B_._12;  _13 := A_ * B_._13;
962
          _21 := A_ * B_._21;  _22 := A_ * B_._22;  _23 := A_ * B_._23;
963
          _31 := A_ * B_._31;  _32 := A_ * B_._32;  _33 := A_ * B_._33;
964
     end;
965
end;
966

967
class operator TdSingleM3.Multiply( const A_:TdSingle3D; const B_:TdSingleM3 ) :TdSingle3D;
968
begin
969
     {
970
                11 12 13
971
       X Y Z × 21 22 23
972
                31 32 33
973
     }
974

975
     with Result do
976
     begin
977
          X := A_.X * B_._11 + A_.Y * B_._21 + A_.Z * B_._31;
978
          Y := A_.X * B_._12 + A_.Y * B_._22 + A_.Z * B_._32;
979
          Z := A_.X * B_._13 + A_.Y * B_._23 + A_.Z * B_._33;
980
     end;
981
end;
982

983
class operator TdSingleM3.Multiply( const A_:TdSingleM3; const B_:TdSingle3D ) :TdSingle3D;
984
begin
985
     {
986
       11 12 13    X
987
       21 22 23 × Y
988
       31 32 33    Z
989
     }
990

991
     with Result do
992
     begin
993
          X := A_._11 * B_.X + A_._12 * B_.Y + A_._13 * B_.Z;
994
          Y := A_._21 * B_.X + A_._22 * B_.Y + A_._23 * B_.Z;
995
          Z := A_._31 * B_.X + A_._32 * B_.Y + A_._33 * B_.Z;
996
     end;
997
end;
998

999
class operator TdSingleM3.Divide( const A_:TdSingleM3; const B_:TdSingle ) :TdSingleM3;
1000
begin
1001
     with Result do
1002
     begin
1003
          _11 := A_._11 / B_;  _12 := A_._12 / B_;  _13 := A_._13 / B_;
1004
          _21 := A_._21 / B_;  _22 := A_._22 / B_;  _23 := A_._23 / B_;
1005
          _31 := A_._31 / B_;  _32 := A_._32 / B_;  _33 := A_._33 / B_;
1006
     end;
1007
end;
1008

1009
/////////////////////////////////////////////////////////////////////// メソッド
1010

1011
function TdSingleM3.Transpose :TdSingleM3;
1012
begin
1013
     Result._11 := _11;  Result._12 := _21;  Result._13 := _31;
1014
     Result._21 := _12;  Result._22 := _22;  Result._23 := _32;
1015
     Result._31 := _13;  Result._32 := _23;  Result._33 := _33;
1016
end;
1017

1018
function TdSingleM3.Det :TdSingle;
1019
begin
1020
     Result:= _11 * ( _22 * _33 - _23 * _32 )
1021
            + _12 * ( _23 * _31 - _21 * _33 )
1022
            + _13 * ( _21 * _32 - _22 * _31 );
1023
end;
1024

1025
function TdSingleM3.Adjugate :TdSingleM3;
1026
begin
1027
     Result._11 := +TdSingleM2.Create( {11} {12} {13}
1028
                                       {21} _22, _23,
1029
                                       {31} _32, _33  ).Det;
1030

1031
     Result._21 := -TdSingleM2.Create( {11} {12} {13}
1032
                                       _21, {22} _23,
1033
                                       _31, {32} _33  ).Det;
1034

1035
     Result._31 := +TdSingleM2.Create( {11} {12} {13}
1036
                                       _21, _22, {23}
1037
                                       _31, _32  {33} ).Det;
1038

1039
     Result._12 := -TdSingleM2.Create( {11} _12, _13,
1040
                                       {21} {22} {23}
1041
                                       {31} _32, _33  ).Det;
1042

1043
     Result._22 := +TdSingleM2.Create( _11, {12} _13,
1044
                                       {21} {22} {23}
1045
                                       _31, {32} _33  ).Det;
1046

1047
     Result._32 := -TdSingleM2.Create( _11, _12, {13}
1048
                                       {21} {22} {23}
1049
                                       _31, _32  {33} ).Det;
1050

1051
     Result._13 := +TdSingleM2.Create( {11} _12, _13,
1052
                                       {21} _22, _23
1053
                                       {31} {32} {33} ).Det;
1054

1055
     Result._23 := -TdSingleM2.Create( _11, {12} _13,
1056
                                       _21, {22} _23
1057
                                       {31} {32} {33} ).Det;
1058

1059
     Result._33 := +TdSingleM2.Create( _11, _12, {13}
1060
                                       _21, _22  {23}
1061
                                       {31} {32} {33} ).Det;
1062
end;
1063

1064
function TdSingleM3.Inverse :TdSingleM3;
1065
var
1066
   A :TdSingleM3;
1067
begin
1068
     A := Adjugate;
1069

1070
     Result := A / ( _11 * A._11
1071
                   + _12 * A._21
1072
                   + _13 * A._31 );
1073
end;
1074

1075
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TdDoubleM3
1076

1077
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
1078

1079
/////////////////////////////////////////////////////////////////////// アクセス
1080

1081
function TdDoubleM3.GetM( const Y_,X_:Integer ) :TdDouble;
1082
begin
1083
     Result := _[ Y_, X_ ];
1084
end;
1085

1086
procedure TdDoubleM3.SetM( const Y_,X_:Integer; const M_:TdDouble );
1087
begin
1088
     _[ Y_, X_ ] := M_;
1089
end;
1090

1091
//------------------------------------------------------------------------------
1092

1093
function TdDoubleM3.GetAxisX :TdDouble3D;
1094
begin
1095
     with Result do
1096
     begin
1097
          X := _11;
1098
          Y := _21;
1099
          Z := _31;
1100
     end;
1101
end;
1102

1103
procedure TdDoubleM3.SetAxisX( const AxisX_:TdDouble3D );
1104
begin
1105
     with AxisX_ do
1106
     begin
1107
          _11 := X;
1108
          _21 := Y;
1109
          _31 := Z;
1110
     end;
1111
end;
1112

1113
function TdDoubleM3.GetAxisY :TdDouble3D;
1114
begin
1115
     with Result do
1116
     begin
1117
          X := _12;
1118
          Y := _22;
1119
          Z := _32;
1120
     end;
1121
end;
1122

1123
procedure TdDoubleM3.SetAxisY( const AxisY_:TdDouble3D );
1124
begin
1125
     with AxisY_ do
1126
     begin
1127
          _12 := X;
1128
          _22 := Y;
1129
          _32 := Z;
1130
     end;
1131
end;
1132

1133
function TdDoubleM3.GetAxisZ :TdDouble3D;
1134
begin
1135
     with Result do
1136
     begin
1137
          X := _13;
1138
          Y := _23;
1139
          Z := _33;
1140
     end;
1141
end;
1142

1143
procedure TdDoubleM3.SetAxisZ( const AxisZ_:TdDouble3D );
1144
begin
1145
     with AxisZ_ do
1146
     begin
1147
          _13 := X;
1148
          _23 := Y;
1149
          _33 := Z;
1150
     end;
1151
end;
1152

1153
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
1154

1155
constructor TdDoubleM3.Create( const _11_,_12_,_13_,
1156
                                     _21_,_22_,_23_,
1157
                                     _31_,_32_,_33_:TdDouble );
1158
begin
1159
     _11 := _11_;  _12 := _12_;  _13 := _13_;
1160
     _21 := _21_;  _22 := _22_;  _23 := _23_;
1161
     _31 := _31_;  _32 := _32_;  _33 := _33_;
1162
end;
1163

1164
///////////////////////////////////////////////////////////////////////// 演算子
1165

1166
class operator TdDoubleM3.Positive( const V_:TdDoubleM3 ) :TdDoubleM3;
1167
begin
1168
     with Result do
1169
     begin
1170
          _11 := +V_._11;  _12 := +V_._12;  _13 := +V_._13;
1171
          _21 := +V_._21;  _22 := +V_._22;  _23 := +V_._23;
1172
          _31 := +V_._31;  _32 := +V_._32;  _33 := +V_._33;
1173
     end;
1174
end;
1175

1176
class operator TdDoubleM3.Negative( const V_:TdDoubleM3 ) :TdDoubleM3;
1177
begin
1178
     with Result do
1179
     begin
1180
          _11 := -V_._11;  _12 := -V_._12;  _13 := -V_._13;
1181
          _21 := -V_._21;  _22 := -V_._22;  _23 := -V_._23;
1182
          _31 := -V_._31;  _32 := -V_._32;  _33 := -V_._33;
1183
     end;
1184
end;
1185

1186
class operator TdDoubleM3.Add( const A_,B_:TdDoubleM3 ) :TdDoubleM3;
1187
begin
1188
     with Result do
1189
     begin
1190
          _11 := A_._11 + B_._11;  _12 := A_._12 + B_._12;  _13 := A_._13 + B_._13;
1191
          _21 := A_._21 + B_._21;  _22 := A_._22 + B_._22;  _23 := A_._23 + B_._23;
1192
          _31 := A_._31 + B_._31;  _32 := A_._32 + B_._32;  _33 := A_._33 + B_._33;
1193
     end;
1194
end;
1195

1196
class operator TdDoubleM3.Subtract( const A_,B_:TdDoubleM3 ) :TdDoubleM3;
1197
begin
1198
     with Result do
1199
     begin
1200
          _11 := A_._11 - B_._11;  _12 := A_._12 - B_._12;  _13 := A_._13 - B_._13;
1201
          _21 := A_._21 - B_._21;  _22 := A_._22 - B_._22;  _23 := A_._23 - B_._23;
1202
          _31 := A_._31 - B_._31;  _32 := A_._32 - B_._32;  _33 := A_._33 - B_._33;
1203
     end;
1204
end;
1205

1206
class operator TdDoubleM3.Multiply( const A_,B_:TdDoubleM3 ) :TdDoubleM3;
1207
begin
1208
     {
1209
       11 12 13    11 12 13
1210
       21 22 23 × 21 22 23
1211
       31 32 33    31 32 33
1212
     }
1213

1214
     with Result do
1215
     begin
1216
          _11 := A_._11 * B_._11 + A_._12 * B_._21 + A_._13 * B_._31;
1217
          _12 := A_._11 * B_._12 + A_._12 * B_._22 + A_._13 * B_._32;
1218
          _13 := A_._11 * B_._13 + A_._12 * B_._23 + A_._13 * B_._33;
1219

1220
          _21 := A_._21 * B_._11 + A_._22 * B_._21 + A_._23 * B_._31;
1221
          _22 := A_._21 * B_._12 + A_._22 * B_._22 + A_._23 * B_._32;
1222
          _23 := A_._21 * B_._13 + A_._22 * B_._23 + A_._23 * B_._33;
1223

1224
          _31 := A_._31 * B_._11 + A_._32 * B_._21 + A_._33 * B_._31;
1225
          _32 := A_._31 * B_._12 + A_._32 * B_._22 + A_._33 * B_._32;
1226
          _33 := A_._31 * B_._13 + A_._32 * B_._23 + A_._33 * B_._33;
1227
     end;
1228
end;
1229

1230
class operator TdDoubleM3.Multiply( const A_:TdDoubleM3; const B_:TdDouble ) :TdDoubleM3;
1231
begin
1232
     with Result do
1233
     begin
1234
          _11 := A_._11 * B_;  _12 := A_._12 * B_;  _13 := A_._13 * B_;
1235
          _21 := A_._21 * B_;  _22 := A_._22 * B_;  _23 := A_._23 * B_;
1236
          _31 := A_._31 * B_;  _32 := A_._32 * B_;  _33 := A_._33 * B_;
1237
     end;
1238
end;
1239

1240
class operator TdDoubleM3.Multiply( const A_:TdDouble; const B_:TdDoubleM3 ) :TdDoubleM3;
1241
begin
1242
     with Result do
1243
     begin
1244
          _11 := A_ * B_._11;  _12 := A_ * B_._12;  _13 := A_ * B_._13;
1245
          _21 := A_ * B_._21;  _22 := A_ * B_._22;  _23 := A_ * B_._23;
1246
          _31 := A_ * B_._31;  _32 := A_ * B_._32;  _33 := A_ * B_._33;
1247
     end;
1248
end;
1249

1250
class operator TdDoubleM3.Multiply( const A_:TdDouble3D; const B_:TdDoubleM3 ) :TdDouble3D;
1251
begin
1252
     {
1253
                11 12 13
1254
       X Y Z × 21 22 23
1255
                31 32 33
1256
     }
1257

1258
     with Result do
1259
     begin
1260
          X := A_.X * B_._11 + A_.Y * B_._21 + A_.Z * B_._31;
1261
          Y := A_.X * B_._12 + A_.Y * B_._22 + A_.Z * B_._32;
1262
          Z := A_.X * B_._13 + A_.Y * B_._23 + A_.Z * B_._33;
1263
     end;
1264
end;
1265

1266
class operator TdDoubleM3.Multiply( const A_:TdDoubleM3; const B_:TdDouble3D ) :TdDouble3D;
1267
begin
1268
     {
1269
       11 12 13    X
1270
       21 22 23 × Y
1271
       31 32 33    Z
1272
     }
1273

1274
     with Result do
1275
     begin
1276
          X := A_._11 * B_.X + A_._12 * B_.Y + A_._13 * B_.Z;
1277
          Y := A_._21 * B_.X + A_._22 * B_.Y + A_._23 * B_.Z;
1278
          Z := A_._31 * B_.X + A_._32 * B_.Y + A_._33 * B_.Z;
1279
     end;
1280
end;
1281

1282
class operator TdDoubleM3.Divide( const A_:TdDoubleM3; const B_:TdDouble ) :TdDoubleM3;
1283
begin
1284
     with Result do
1285
     begin
1286
          _11 := A_._11 / B_;  _12 := A_._12 / B_;  _13 := A_._13 / B_;
1287
          _21 := A_._21 / B_;  _22 := A_._22 / B_;  _23 := A_._23 / B_;
1288
          _31 := A_._31 / B_;  _32 := A_._32 / B_;  _33 := A_._33 / B_;
1289
     end;
1290
end;
1291

1292
/////////////////////////////////////////////////////////////////////// メソッド
1293

1294
function TdDoubleM3.Transpose :TdDoubleM3;
1295
begin
1296
     Result._11 := _11;  Result._12 := _21;  Result._13 := _31;
1297
     Result._21 := _12;  Result._22 := _22;  Result._23 := _32;
1298
     Result._31 := _13;  Result._32 := _23;  Result._33 := _33;
1299
end;
1300

1301
function TdDoubleM3.Det :TdDouble;
1302
begin
1303
     Result:= _11 * ( _22 * _33 - _23 * _32 )
1304
            + _12 * ( _23 * _31 - _21 * _33 )
1305
            + _13 * ( _21 * _32 - _22 * _31 );
1306
end;
1307

1308
function TdDoubleM3.Adjugate :TdDoubleM3;
1309
begin
1310
     Result._11 := +TdDoubleM2.Create( {11} {12} {13}
1311
                                       {21} _22, _23,
1312
                                       {31} _32, _33  ).Det;
1313

1314
     Result._21 := -TdDoubleM2.Create( {11} {12} {13}
1315
                                       _21, {22} _23,
1316
                                       _31, {32} _33  ).Det;
1317

1318
     Result._31 := +TdDoubleM2.Create( {11} {12} {13}
1319
                                       _21, _22, {23}
1320
                                       _31, _32  {33} ).Det;
1321

1322
     Result._12 := -TdDoubleM2.Create( {11} _12, _13,
1323
                                       {21} {22} {23}
1324
                                       {31} _32, _33  ).Det;
1325

1326
     Result._22 := +TdDoubleM2.Create( _11, {12} _13,
1327
                                       {21} {22} {23}
1328
                                       _31, {32} _33  ).Det;
1329

1330
     Result._32 := -TdDoubleM2.Create( _11, _12, {13}
1331
                                       {21} {22} {23}
1332
                                       _31, _32  {33} ).Det;
1333

1334
     Result._13 := +TdDoubleM2.Create( {11} _12, _13,
1335
                                       {21} _22, _23
1336
                                       {31} {32} {33} ).Det;
1337

1338
     Result._23 := -TdDoubleM2.Create( _11, {12} _13,
1339
                                       _21, {22} _23
1340
                                       {31} {32} {33} ).Det;
1341

1342
     Result._33 := +TdDoubleM2.Create( _11, _12, {13}
1343
                                       _21, _22  {23}
1344
                                       {31} {32} {33} ).Det;
1345
end;
1346

1347
function TdDoubleM3.Inverse :TdDoubleM3;
1348
var
1349
   A :TdDoubleM3;
1350
begin
1351
     A := Adjugate;
1352

1353
     Result := A / ( _11 * A._11
1354
                   + _12 * A._21
1355
                   + _13 * A._31 );
1356
end;
1357

1358
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
1359

1360
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
1361

1362
//############################################################################## □
1363

1364
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
1365

1366
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 最終化
1367

1368
end. //######################################################################### ■
1369