Luxophia

1
unit LUX.Complex;
2

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

5
uses LUX;
6

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

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

11
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSingleC
12

13
     TSingleC = record
14
     private
15
       ///// アクセサ
16
       function GetSiz2 :Single;
17
       function GetSize :Single;
18
       procedure SetSize( const Size_:Single );
19
       function GetUnitor :TSingleC;
20
       procedure SetUnitor( const Unitor_:TSingleC );
21
       function GetConj :TSingleC;
22
       procedure SetConj( const Conj_:TSingleC );
23
       function GetAngle :Single;
24
     public
25
       R :Single;
26
       I :Single;
27
       /////
28
       constructor Create( const R_,I_:Single );
29
       ///// プロパティ
30
       property Siz2   :Single   read GetSiz2                  ;
31
       property Size   :Single   read GetSize   write SetSize  ;
32
       property Unitor :TSingleC read GetUnitor write SetUnitor;
33
       property Conj   :TSingleC read GetConj   write SetConj  ;
34
       property Angle  :Single   read GetAngle                 ;
35
       ///// 演算子
36
       class operator Negative( const V_:TSingleC ) :TSingleC;
37
       class operator Positive( const V_:TSingleC ) :TSingleC;
38
       class operator Add( const A_,B_:TSingleC ) :TSingleC;
39
       class operator Subtract( const A_,B_:TSingleC ) :TSingleC;
40
       class operator Multiply( const A_,B_:TSingleC ) :TSingleC;
41
       class operator Multiply( const A_:TSingleC; const B_:Single ) :TSingleC;
42
       class operator Multiply( const A_:Single; const B_:TSingleC ) :TSingleC;
43
       class operator Divide( const A_,B_:TSingleC ) :TSingleC;
44
       class operator Divide( const A_:TSingleC; const B_:Single ) :TSingleC;
45
       ///// 型変換
46
       class operator Implicit( const V_:Single ) :TSingleC;
47
     end;
48

49
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleC
50

51
     TDoubleC = record
52
     private
53
       ///// アクセサ
54
       function GetSiz2 :Double;
55
       function GetSize :Double;
56
       procedure SetSize( const Size_:Double );
57
       function GetUnitor :TDoubleC;
58
       procedure SetUnitor( const Unitor_:TDoubleC );
59
       function GetConj :TDoubleC;
60
       procedure SetConj( const Conj_:TDoubleC );
61
       function GetAngle :Double;
62
     public
63
       R :Double;
64
       I :Double;
65
       /////
66
       constructor Create( const R_,I_:Double );
67
       ///// プロパティ
68
       property Siz2   :Double   read GetSiz2                  ;
69
       property Size   :Double   read GetSize   write SetSize  ;
70
       property Unitor :TDoubleC read GetUnitor write SetUnitor;
71
       property Conj   :TDoubleC read GetConj   write SetConj  ;
72
       property Angle  :Double   read GetAngle                 ;
73
       ///// 演算子
74
       class operator Negative( const V_:TDoubleC ) :TDoubleC;
75
       class operator Positive( const V_:TDoubleC ) :TDoubleC;
76
       class operator Add( const A_,B_:TDoubleC ) :TDoubleC;
77
       class operator Subtract( const A_,B_:TDoubleC ) :TDoubleC;
78
       class operator Multiply( const A_,B_:TDoubleC ) :TDoubleC;
79
       class operator Multiply( const A_:TDoubleC; const B_:Double ) :TDoubleC;
80
       class operator Multiply( const A_:Double; const B_:TDoubleC ) :TDoubleC;
81
       class operator Divide( const A_,B_:TDoubleC ) :TDoubleC;
82
       class operator Divide( const A_:TDoubleC; const B_:Double ) :TDoubleC;
83
       ///// 型変換
84
       class operator Implicit( const V_:Double ) :TDoubleC;
85
       class operator Implicit( const V_:TSingleC ) :TDoubleC;
86
       class operator Implicit( const V_:TDoubleC ) :TSingleC;
87
     end;
88

89
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSingleAreaC
90

91
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleAreaC
92

93
     TDoubleAreaC = record
94
     private
95
       _Min :TDoubleC;
96
       _Max :TDoubleC;
97
       ///// アクセサ
98
       function GetCenter :TDoubleC;
99
       procedure SetCenter( const Center_:TDoubleC );
100
       function GetCenterR :Double;
101
       procedure SetCenterR( const CenterR_:Double );
102
       function GetCenterI :Double;
103
       procedure SetCenterI( const CenterI_:Double );
104
       function GetSizeR :Double;
105
       procedure SetSizeR( const SizeR_:Double );
106
       function GetSizeI :Double;
107
       procedure SetSizeI( const SizeI_:Double );
108
     public
109
       /////
110
       constructor Create( const Min_,Max_:TDoubleC ); overload;
111
       constructor Create( const MinR_,MinI_,MaxR_,MaxI_:Double ); overload;
112
       ///// プロパティ
113
       property Min     :TDoubleC read   _Min     write   _Min    ;
114
       property Max     :TDoubleC read   _Max     write   _Max    ;
115
       property Center  :TDoubleC read GetCenter  write SetCenter ;
116
       property CenterR :Double   read GetCenterR write SetCenterR;
117
       property CenterI :Double   read GetCenterI write SetCenterI;
118
       property SizeR   :Double   read GetSizeR   write SetSizeR  ;
119
       property SizeI   :Double   read GetSizeI   write SetSizeI  ;
120
       ///// 演算子
121
       class operator Negative( const V_:TDoubleAreaC ) :TDoubleAreaC;
122
       class operator Positive( const V_:TDoubleAreaC ) :TDoubleAreaC;
123
       class operator Add( const A_,B_:TDoubleAreaC ) :TDoubleAreaC;
124
       class operator Subtract( const A_,B_:TDoubleAreaC ) :TDoubleAreaC;
125
       class operator Multiply( const A_:TDoubleAreaC; const B_:Double ) :TDoubleAreaC;
126
       class operator Multiply( const A_:Double; const B_:TDoubleAreaC ) :TDoubleAreaC;
127
       class operator Divide( const A_:TDoubleAreaC; const B_:Double ) :TDoubleAreaC;
128
       ///// 型変換
129
     end;
130

131
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
132

133
const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
134

135
Imaginary :TDoubleC = ( R:0; I:1 );
136

137
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
138

139
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
140

141
function Pow( const X_:TSingleC; const N_:Single ) :TSingleC; overload;
142
function Pow( const X_:TDoubleC; const N_:Double ) :TDoubleC; overload;
143

144
function Roo2( const X_:TSingleC ) :TSingleC; overload;
145
function Roo2( const X_:TDoubleC ) :TDoubleC; overload;
146

147
function Cos( const A_:TSingleC ) :TSingleC; overload;
148
function Cos( const A_:TDoubleC ) :TDoubleC; overload;
149

150
function Sin( const A_:TSingleC ) :TSingleC; overload;
151
function Sin( const A_:TDoubleC ) :TDoubleC; overload;
152

153
function Tan( const A_:TSingleC ) :TSingleC; overload;
154
function Tan( const A_:TDoubleC ) :TDoubleC; overload;
155

156
function Exp( const A_:TSingleC ) :TSingleC; overload;
157
function Exp( const A_:TDoubleC ) :TDoubleC; overload;
158

159
function Ln( const A_:TSingleC ) :TSingleC; overload;
160
function Ln( const A_:TDoubleC ) :TDoubleC; overload;
161

162
function ArcCos( const X_:TDoubleC ) :TDoubleC; overload;
163

164
function ArcSin( const X_:TDoubleC ) :TDoubleC; overload;
165

166
implementation //############################################################### ■
167

168
uses System.Math;
169

170
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
171

172
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TSingleC
173

174
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
175

176
function TSingleC.GetSiz2 :Single;
177
begin
178
     Result := Pow2( R ) + Pow2( I )
179
end;
180

181
function TSingleC.GetSize :Single;
182
begin
183
     Result := Roo2( GetSiz2 )
184
end;
185

186
procedure TSingleC.SetSize( const Size_:Single );
187
begin
188
     Self := Size_ * Unitor
189
end;
190

191
function TSingleC.GetUnitor :TSingleC;
192
begin
193
     Result := Self / Size
194
end;
195

196
procedure TSingleC.SetUnitor( const Unitor_:TSingleC );
197
begin
198
     Self := Size * Unitor_
199
end;
200

201
function TSingleC.GetConj :TSingleC;
202
begin
203
     Result.R := +R;
204
     Result.I := -I;
205
end;
206

207
procedure TSingleC.SetConj( const Conj_:TSingleC );
208
begin
209
     R := +Conj_.R;
210
     I := -Conj_.I;
211
end;
212

213
function TSingleC.GetAngle :Single;
214
begin
215
     Result := ArcTan2( I, R )
216
end;
217

218
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
219

220
constructor TSingleC.Create( const R_,I_:Single );
221
begin
222
     R := R_;
223
     I := I_;
224
end;
225

226
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 演算子
227

228
class operator TSingleC.Negative( const V_:TSingleC ) :TSingleC;
229
begin
230
     with Result do
231
     begin
232
          R := -V_.R;
233
          I := -V_.I;
234
     end
235
end;
236

237
class operator TSingleC.Positive( const V_:TSingleC ) :TSingleC;
238
begin
239
     with Result do
240
     begin
241
          R := +V_.R;
242
          I := +V_.I;
243
     end
244
end;
245

246
class operator TSingleC.Add( const A_,B_:TSingleC ) :TSingleC;
247
begin
248
     with Result do
249
     begin
250
          R := A_.R + B_.R;
251
          I := A_.I + B_.I;
252
     end
253
end;
254

255
class operator TSingleC.Subtract( const A_,B_:TSingleC ) :TSingleC;
256
begin
257
     with Result do
258
     begin
259
          R := A_.R - B_.R;
260
          I := A_.I - B_.I;
261
     end
262
end;
263

264
class operator TSingleC.Multiply( const A_,B_:TSingleC ) :TSingleC;
265
begin
266
     with Result do
267
     begin
268
          R := A_.R * B_.R - A_.I * B_.I;
269
          I := A_.R * B_.I + A_.I * B_.R;
270
     end
271
end;
272

273
class operator TSingleC.Multiply( const A_:TSingleC; const B_:Single ) :TSingleC;
274
begin
275
     with Result do
276
     begin
277
          R := A_.R * B_;
278
          I := A_.I * B_;
279
     end
280
end;
281

282
class operator TSingleC.Multiply( const A_:Single; const B_:TSingleC ) :TSingleC;
283
begin
284
     with Result do
285
     begin
286
          R := A_ * B_.R;
287
          I := A_ * B_.I;
288
     end
289
end;
290

291
class operator TSingleC.Divide( const A_,B_:TSingleC ) :TSingleC;
292
var
293
   C :Single;
294
begin
295
     C := B_.Siz2;
296

297
     with Result do
298
     begin
299
          R := ( A_.R * B_.R + A_.I * B_.I ) / C;
300
          I := ( A_.I * B_.R - A_.R * B_.I ) / C;
301
     end
302
end;
303

304
class operator TSingleC.Divide( const A_:TSingleC; const B_:Single ) :TSingleC;
305
begin
306
     with Result do
307
     begin
308
          R := A_.R / B_;
309
          I := A_.I / B_;
310
     end
311
end;
312

313
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 型変換
314

315
class operator TSingleC.Implicit( const V_:Single ) :TSingleC;
316
begin
317
     with Result do
318
     begin
319
          R := V_;
320
          I := 0;
321
     end
322
end;
323

324
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleC
325

326
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
327

328
function TDoubleC.GetSiz2 :Double;
329
begin
330
     Result := Pow2( R ) + Pow2( I )
331
end;
332

333
function TDoubleC.GetSize :Double;
334
begin
335
     Result := Roo2( GetSiz2 )
336
end;
337

338
procedure TDoubleC.SetSize( const Size_:Double );
339
begin
340
     Self := Size_ * Unitor
341
end;
342

343
function TDoubleC.GetUnitor :TDoubleC;
344
begin
345
     Result := Self / Size
346
end;
347

348
procedure TDoubleC.SetUnitor( const Unitor_:TDoubleC );
349
begin
350
     Self := Size * Unitor_
351
end;
352

353
function TDoubleC.GetConj :TDoubleC;
354
begin
355
     Result.R := +R;
356
     Result.I := -I;
357
end;
358

359
procedure TDoubleC.SetConj( const Conj_:TDoubleC );
360
begin
361
     R := +Conj_.R;
362
     I := -Conj_.I;
363
end;
364

365
function TDoubleC.GetAngle :Double;
366
begin
367
     Result := ArcTan2( I, R )
368
end;
369

370
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
371

372
constructor TDoubleC.Create( const R_,I_:Double );
373
begin
374
     R := R_;
375
     I := I_;
376
end;
377

378
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 演算子
379

380
class operator TDoubleC.Negative( const V_:TDoubleC ) :TDoubleC;
381
begin
382
     with Result do
383
     begin
384
          R := -V_.R;
385
          I := -V_.I;
386
     end
387
end;
388

389
class operator TDoubleC.Positive( const V_:TDoubleC ) :TDoubleC;
390
begin
391
     with Result do
392
     begin
393
          R := +V_.R;
394
          I := +V_.I;
395
     end
396
end;
397

398
class operator TDoubleC.Add( const A_,B_:TDoubleC ) :TDoubleC;
399
begin
400
     with Result do
401
     begin
402
          R := A_.R + B_.R;
403
          I := A_.I + B_.I;
404
     end
405
end;
406

407
class operator TDoubleC.Subtract( const A_,B_:TDoubleC ) :TDoubleC;
408
begin
409
     with Result do
410
     begin
411
          R := A_.R - B_.R;
412
          I := A_.I - B_.I;
413
     end
414
end;
415

416
class operator TDoubleC.Multiply( const A_,B_:TDoubleC ) :TDoubleC;
417
begin
418
     with Result do
419
     begin
420
          R := A_.R * B_.R - A_.I * B_.I;
421
          I := A_.R * B_.I + A_.I * B_.R;
422
     end
423
end;
424

425
class operator TDoubleC.Multiply( const A_:TDoubleC; const B_:Double ) :TDoubleC;
426
begin
427
     with Result do
428
     begin
429
          R := A_.R * B_;
430
          I := A_.I * B_;
431
     end
432
end;
433

434
class operator TDoubleC.Multiply( const A_:Double; const B_:TDoubleC ) :TDoubleC;
435
begin
436
     with Result do
437
     begin
438
          R := A_ * B_.R;
439
          I := A_ * B_.I;
440
     end
441
end;
442

443
class operator TDoubleC.Divide( const A_,B_:TDoubleC ) :TDoubleC;
444
var
445
   C :Double;
446
begin
447
     C := B_.Siz2;
448

449
     with Result do
450
     begin
451
          R := ( A_.R * B_.R + A_.I * B_.I ) / C;
452
          I := ( A_.I * B_.R - A_.R * B_.I ) / C;
453
     end
454
end;
455

456
class operator TDoubleC.Divide( const A_:TDoubleC; const B_:Double ) :TDoubleC;
457
begin
458
     with Result do
459
     begin
460
          R := A_.R / B_;
461
          I := A_.I / B_;
462
     end
463
end;
464

465
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 型変換
466

467
class operator TDoubleC.Implicit( const V_:Double ) :TDoubleC;
468
begin
469
     with Result do
470
     begin
471
          R := V_;
472
          I := 0;
473
     end
474
end;
475

476
class operator TDoubleC.Implicit( const V_:TSingleC ) :TDoubleC;
477
begin
478
     with Result do
479
     begin
480
          R := V_.R;
481
          I := V_.I;
482
     end
483
end;
484

485
class operator TDoubleC.Implicit( const V_:TDoubleC ) :TSingleC;
486
begin
487
     with Result do
488
     begin
489
          R := V_.R;
490
          I := V_.I;
491
     end
492
end;
493

494
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TDoubleAreaC
495

496
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
497

498
function TDoubleAreaC.GetCenter :TDoubleC;
499
begin
500
     Result := ( _Max + _Min ) / 2
501
end;
502

503
procedure TDoubleAreaC.SetCenter( const Center_:TDoubleC );
504
begin
505
     with Center_ do
506
     begin
507
          CenterR := R;
508
          CenterI := I;
509
     end
510
end;
511

512
function TDoubleAreaC.GetCenterR :Double;
513
begin
514
     Result := ( _Max.R + _Min.R ) / 2
515
end;
516

517
procedure TDoubleAreaC.SetCenterR( const CenterR_:Double );
518
var
519
   S :Double;
520
begin
521
     S := SizeR / 2;
522

523
     _Min.R := CenterR_ - S;
524
     _Max.R := CenterR_ + S;
525
end;
526

527
function TDoubleAreaC.GetCenterI :Double;
528
begin
529
     Result := ( _Max.I + _Min.I ) / 2
530
end;
531

532
procedure TDoubleAreaC.SetCenterI( const CenterI_:Double );
533
var
534
   S :Double;
535
begin
536
     S := SizeI / 2;
537

538
     _Min.I := CenterI_ - S;
539
     _Max.I := CenterI_ + S;
540
end;
541

542
function TDoubleAreaC.GetSizeR :Double;
543
begin
544
     Result := _Max.R - _Min.R
545
end;
546

547
procedure TDoubleAreaC.SetSizeR( const SizeR_:Double );
548
var
549
   C, S :Double;
550
begin
551
     C := CenterR;
552
     S := SizeR_ / 2;
553

554
     _Min.R := C - S;
555
     _Max.R := C + S;
556
end;
557

558
function TDoubleAreaC.GetSizeI :Double;
559
begin
560
     Result := _Max.I - _Min.I
561
end;
562

563
procedure TDoubleAreaC.SetSizeI( const SizeI_:Double );
564
var
565
   C, S :Double;
566
begin
567
     C := CenterI;
568
     S := SizeI_ / 2;
569

570
     _Min.I := C - S;
571
     _Max.I := C + S;
572
end;
573

574
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
575

576
constructor TDoubleAreaC.Create( const Min_,Max_:TDoubleC );
577
begin
578
     _Min := Min_;
579
     _Max := Max_;
580
end;
581

582
constructor TDoubleAreaC.Create( const MinR_,MinI_,MaxR_,MaxI_:Double );
583
begin
584
     with _Min do
585
     begin
586
          R := MinR_;
587
          I := MinI_;
588
     end;
589
     with _Max do
590
     begin
591
          R := MaxR_;
592
          I := MaxI_;
593
     end;
594
end;
595

596
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 演算子
597

598
class operator TDoubleAreaC.Negative( const V_:TDoubleAreaC ) :TDoubleAreaC;
599
begin
600
     with Result do
601
     begin
602
          _Min := -V_._Min;
603
          _Max := -V_._Max;
604
     end
605
end;
606

607
class operator TDoubleAreaC.Positive( const V_:TDoubleAreaC ) :TDoubleAreaC;
608
begin
609
     with Result do
610
     begin
611
          _Min := +V_._Min;
612
          _Max := +V_._Max;
613
     end
614
end;
615

616
class operator TDoubleAreaC.Add( const A_,B_:TDoubleAreaC ) :TDoubleAreaC;
617
begin
618
     with Result do
619
     begin
620
          _Min := A_._Min + B_._Min;
621
          _Max := A_._Max + B_._Max;
622
     end
623
end;
624

625
class operator TDoubleAreaC.Subtract( const A_,B_:TDoubleAreaC ) :TDoubleAreaC;
626
begin
627
     with Result do
628
     begin
629
          _Min := A_._Min - B_._Min;
630
          _Max := A_._Max - B_._Max;
631
     end
632
end;
633

634
class operator TDoubleAreaC.Multiply( const A_:TDoubleAreaC; const B_:Double ) :TDoubleAreaC;
635
begin
636
     with Result do
637
     begin
638
          _Min := A_._Min * B_;
639
          _Max := A_._Max * B_;
640
     end
641
end;
642

643
class operator TDoubleAreaC.Multiply( const A_:Double; const B_:TDoubleAreaC ) :TDoubleAreaC;
644
begin
645
     with Result do
646
     begin
647
          _Min := A_ * B_._Min;
648
          _Max := A_ * B_._Max;
649
     end
650
end;
651

652
class operator TDoubleAreaC.Divide( const A_:TDoubleAreaC; const B_:Double ) :TDoubleAreaC;
653
begin
654
     with Result do
655
     begin
656
          _Min := A_._Min / B_;
657
          _Max := A_._Max / B_;
658
     end
659
end;
660

661
//XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 型変換
662

663

664
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
665

666
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
667

668
function Pow( const X_:TSingleC; const N_:Single ) :TSingleC;
669
var
670
   S, A: Single;
671
begin
672
     S := Power( X_.Size, N_ );
673
     A := X_.Angle * N_;
674

675
     Result.R := S * Cos( A );
676
     Result.I := S * Sin( A );
677
end;
678

679
function Pow( const X_:TDoubleC; const N_:Double ) :TDoubleC;
680
var
681
   S, A: Double;
682
begin
683
     S := Power( X_.Size, N_ );
684
     A := X_.Angle * N_;
685

686
     Result.R := S * Cos( A );
687
     Result.I := S * Sin( A );
688
end;
689

690
////////////////////////////////////////////////////////////////////////////////
691

692
function Roo2( const X_:TSingleC ) :TSingleC;
693
var
694
   S, A: Single;
695
begin
696
     S := Roo2( X_.Size );
697
     A := X_.Angle / 2;
698

699
     Result.R := S * Cos( A );
700
     Result.I := S * Sin( A );
701
end;
702

703
function Roo2( const X_:TDoubleC ) :TDoubleC;
704
var
705
   S, A: Double;
706
begin
707
     S := Roo2( X_.Size );
708
     A := X_.Angle / 2;
709

710
     Result.R := S * Cos( A );
711
     Result.I := S * Sin( A );
712
end;
713

714
////////////////////////////////////////////////////////////////////////////////
715

716
function Cos( const A_:TSingleC ) :TSingleC;
717
begin
718
     with A_ do
719
     begin
720
          Result.R := +Cos( R ) * Cosh( I );
721
          Result.I := -Sin( R ) * Sinh( I );
722
     end
723
end;
724

725
function Cos( const A_:TDoubleC ) :TDoubleC;
726
begin
727
     with A_ do
728
     begin
729
          Result.R := +Cos( R ) * Cosh( I );
730
          Result.I := -Sin( R ) * Sinh( I );
731
     end
732
end;
733

734
////////////////////////////////////////////////////////////////////////////////
735

736
function Sin( const A_:TSingleC ) :TSingleC;
737
begin
738
     with A_ do
739
     begin
740
          Result.R := +Sin( R ) * Cosh( I );
741
          Result.I := +Cos( R ) * Sinh( I );
742
     end
743
end;
744

745
function Sin( const A_:TDoubleC ) :TDoubleC;
746
begin
747
     with A_ do
748
     begin
749
          Result.R := +Sin( R ) * Cosh( I );
750
          Result.I := +Cos( R ) * Sinh( I );
751
     end
752
end;
753

754
////////////////////////////////////////////////////////////////////////////////
755

756
function Tan( const A_:TSingleC ) :TSingleC;
757
begin
758
     Result := Sin( A_ ) / Cos( A_ );
759
end;
760

761
function Tan( const A_:TDoubleC ) :TDoubleC;
762
begin
763
     Result := Sin( A_ ) / Cos( A_ );
764
end;
765

766
////////////////////////////////////////////////////////////////////////////////
767

768
function Exp( const A_:TSingleC ) :TSingleC;
769
var
770
   E :Single;
771
begin
772
     with A_ do
773
     begin
774
          E := Exp( R );
775

776
          Result.R := E * Cos( I );
777
          Result.I := E * Sin( I );
778
     end
779
end;
780

781
function Exp( const A_:TDoubleC ) :TDoubleC;
782
var
783
   E :Double;
784
begin
785
     with A_ do
786
     begin
787
          E := Exp( R );
788

789
          Result.R := E * Cos( I );
790
          Result.I := E * Sin( I );
791
     end
792
end;
793

794
////////////////////////////////////////////////////////////////////////////////
795

796
function Ln( const A_:TSingleC ) :TSingleC;
797
begin
798
     with A_ do
799
     begin
800
          Result.R := Ln( Size );
801
          Result.I := Angle;
802
     end
803
end;
804

805
function Ln( const A_:TDoubleC ) :TDoubleC;
806
begin
807
     with A_ do
808
     begin
809
          Result.R := Ln( Size );
810
          Result.I := Angle;
811
     end
812
end;
813

814
////////////////////////////////////////////////////////////////////////////////
815

816
function ArcCos( const X_:TDoubleC ) :TDoubleC;
817
begin
818
     Result := +Imaginary * Ln( X_ + Imaginary * Roo2( 1 - X_ * X_ ) );
819
end;
820

821
function ArcSin( const X_:TDoubleC ) :TDoubleC;
822
begin
823
     Result := -Imaginary * Ln( Imaginary * X_ + Roo2( 1 - X_ * X_ ) );
824
end;
825

826
//############################################################################## □
827

828
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
829

830
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 最終化
831

832
end. //######################################################################### ■
833