Luxophia

1
unit LUX.Data.Lattice.T1;
2

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

5
uses System.SysUtils,
6
     LUX;
7

8
type //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【型】
9

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

12
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TPosval1D<_TItem_>
13

14
     TPosval1D<_TItem_> = record
15
     private
16
     public
17
       Pos :Single;
18
       Val :_TItem_;
19
       /////
20
       constructor Create( const Pos_:Single; const Val_:_TItem_ );
21
     end;
22

23
     //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
24

25
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TArray1D<_TItem_>
26

27
     IArray1D = interface
28
     ['{7BF64031-75DC-4CD8-9220-78D0F556C4CB}']
29
       ///// アクセス
30
       function GetItemByte :Integer;
31
       function GetElemsP0 :Pointer;
32
       function GetElemsX :Integer;
33
       function GetElemsN :Integer;
34
       function GetElemsByte :Integer;
35
       function GetItemsX :Integer;
36
       procedure SetItemsX( const ItemsX_:Integer );
37
       function GetMargsX :Integer;
38
       procedure SetMargsX( const MargsX_:Integer );
39
       ///// プロパティ
40
       property ItemByte  :Integer read GetItemByte                 ;
41
       property ElemsP0   :Pointer read GetElemsP0                  ;
42
       property ElemsX    :Integer read GetElemsX                   ;
43
       property ElemsN    :Integer read GetElemsN                   ;
44
       property ElemsByte :Integer read GetElemsByte                ;
45
       property ItemsX    :Integer read GetItemsX    write SetItemsX;
46
       property MargsX    :Integer read GetMargsX    write SetMargsX;
47
     end;
48

49
     //-------------------------------------------------------------------------
50

51
     TArray1D<_TItem_> = class( TInterfacedBase, IArray1D )
52
     public type
53
       _PItem_ = ^_TItem_;
54
     private
55
       ///// メソッド
56
       procedure MakeArray;
57
       function XtoI( const X_:Integer ) :Integer; inline;
58
     protected
59
       _Elems  :TArray<_TItem_>;
60
       _ElemsX :Integer;
61
       _ItemsX :Integer;
62
       _MargsX :Integer;
63
       ///// アクセス
64
       function GetItemByte :Integer;
65
       function GetElemsP0 :Pointer;
66
       function GetElemsX :Integer;
67
       function GetElemsN :Integer;
68
       function GetElemsByte :Integer;
69
       function GetItems( const X_:Integer ) :_TItem_; virtual;
70
       procedure SetItems( const X_:Integer; const Item_:_TItem_ ); virtual;
71
       function GetItemP( const X_:Integer ) :_PItem_;
72
       function GetItemsX :Integer;
73
       procedure SetItemsX( const ItemsX_:Integer );
74
       function GetMargsX :Integer;
75
       procedure SetMargsX( const MargsX_:Integer );
76
     public
77
       ///// イベント
78
       _OnChange :TProc;
79
     public
80
       constructor Create; overload;
81
       constructor Create( const ItemsX_:Integer ); overload;
82
       constructor Create( const ItemsX_,MargsX_:Integer ); overload; virtual;
83
       procedure AfterConstruction; override;
84
       destructor Destroy; override;
85
       ///// プロパティ
86
       property ItemByte                  :Integer read GetItemByte                 ;
87
       property ElemsP0                   :Pointer read GetElemsP0                  ;
88
       property ElemsX                    :Integer read GetElemsX                   ;
89
       property ElemsN                    :Integer read GetElemsN                   ;
90
       property ElemsByte                 :Integer read GetElemsByte                ;
91
       property Items[ const X_:Integer ] :_TItem_ read GetItems     write SetItems ; default;
92
       property ItemP[ const X_:Integer ] :_PItem_ read GetItemP                    ;
93
       property ItemsN                    :Integer read GetItemsX    write SetItemsX;
94
       property ItemsX                    :Integer read GetItemsX    write SetItemsX;
95
       property MargsN                    :Integer read GetMargsX    write SetMargsX;
96
       property MargsX                    :Integer read GetMargsX    write SetMargsX;
97
       ///// メソッド
98
       class procedure Swap( var Array0_,Array1_:TArray1D<_TItem_> ); static;
99
       procedure MakeEdgeExten; virtual;
100
       procedure MakeEdgePerio; virtual; abstract;
101
       procedure MakeEdgeMirro; virtual; abstract;
102
       function AddTail( const Item_:_TItem_ ) :Integer;
103
     end;
104

105
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TBricArray1D<_TItem_>
106

107
     IBricArray1D = interface( IArray1D )
108
     ['{970CB18E-E1DC-4393-A124-528256753896}']
109
       ///// アクセス
110
       function GetGridsX :Integer;
111
       procedure SetGridsX( const GridX_:Integer );
112
       ///// プロパティ
113
       property BricsX :Integer read GetItemsX write SetItemsX;
114
       property GridsX :Integer read GetGridsX write SetGridsX;
115
     end;
116

117
     //-------------------------------------------------------------------------
118

119
     TBricArray1D<_TItem_> = class( TArray1D<_TItem_>, IBricArray1D )
120
     private
121
     protected
122
       ///// アクセス
123
       function GetGridsX :Integer;
124
       procedure SetGridsX( const GridsX_:Integer );
125
     public
126
       ///// プロパティ
127
       property Brics[ const X_:Integer ] :_TItem_ read GetItems  write SetItems ; default;
128
       property BricsN                    :Integer read GetItemsX write SetItemsX;
129
       property BricsX                    :Integer read GetItemsX write SetItemsX;
130
       property GridsN                    :Integer read GetGridsX write SetGridsX;
131
       property GridsX                    :Integer read GetGridsX write SetGridsX;
132
       ///// メソッド
133
       procedure MakeEdgePerio; override;
134
       procedure MakeEdgeMirro; override;
135
     end;
136

137
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TGridArray1D<_TItem_>
138

139
     IGridArray1D = interface( IArray1D )
140
     ['{9FF11CDA-0879-41D1-8025-C4323E1D4389}']
141
       ///// アクセス
142
       function GetBricsX :Integer;
143
       procedure SetBricsX( const BricsX_:Integer );
144
       ///// プロパティ
145
       property GridsX :Integer read GetItemsX write SetItemsX;
146
       property BricsX :Integer read GetBricsX write SetBricsX;
147
     end;
148

149
     //-------------------------------------------------------------------------
150

151
     TGridArray1D<_TItem_> = class( TArray1D<_TItem_>, IGridArray1D )
152
     private
153
     protected
154
       ///// アクセス
155
       function GetBricsX :Integer;
156
       procedure SetBricsX( const BricsX_:Integer );
157
     public
158
       constructor Create( const BricsX_,MargsX_:Integer ); override;
159
       destructor Destroy; override;
160
       ///// プロパティ
161
       property Grids[ const X_:Integer ] :_TItem_ read GetItems  write SetItems ; default;
162
       property GridsN                    :Integer read GetItemsX write SetItemsX;
163
       property GridsX                    :Integer read GetItemsX write SetItemsX;
164
       property BricsN                    :Integer read GetBricsX write SetBricsX;
165
       property BricsX                    :Integer read GetBricsX write SetBricsX;
166
       ///// メソッド
167
       procedure MakeEdgePerio; override;
168
       procedure MakeEdgeMirro; override;
169
     end;
170

171
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TGridMap1D<_TItem_>
172

173
     TGridMap1D<_TItem_> = class( TGridArray1D<_TItem_> )
174
     private
175
     protected
176
     public
177
     end;
178

179
     //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TIrreMap1D<_TItem_>
180

181
     TIrreMap1D<_TItem_> = class( TGridMap1D<TPosval1D<_TItem_>> )
182
     private
183
     protected
184
       ///// アクセス
185
       function GetMinPosX :Single;
186
       function GetMaxPosX :Single;
187
       ///// メソッド
188
       function Interp( const G0_,G1_,G2_,G3_:_TItem_; const Id_:Single ) :_TItem_; overload; virtual; abstract;
189
       function InterpPos( const G0_,G1_,G2_,G3_:TPosval1D<_TItem_>; const Pos_:Single ) :_TItem_; overload; virtual; abstract;
190
     public
191
       ///// プロパティ
192
       property MinPos  :Single read GetMinPosX;
193
       property MinPosX :Single read GetMinPosX;
194
       property MaxPos  :Single read GetMaxPosX;
195
       property MaxPosX :Single read GetMaxPosX;
196
       ///// メソッド
197
       function Interp( const I_:Single ) :_TItem_; overload; virtual;
198
       function InterpPos( const Pos_:Single ) :_TItem_; overload; virtual;
199
       function AddTail( const Pos_:Single; const Val_:_TItem_ ) :Integer; overload;
200
       function Insert( const PV_:TPosval1D<_TItem_> ) :Integer; overload; virtual;
201
       function Insert( const Pos_:Single; const Val_:_TItem_ ) :Integer; overload; virtual;
202
     end;
203

204
//const //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【定数】
205

206
//var //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【変数】
207

208
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
209

210
implementation //############################################################### ■
211

212
uses System.Math;
213

214
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【レコード】
215

216
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TPosval1D<_TItem_>
217

218
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
219

220
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
221

222
constructor TPosval1D<_TItem_>.Create( const Pos_:Single; const Val_:_TItem_ );
223
begin
224
     Pos := Pos_;
225
     Val := Val_;
226
end;
227

228
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【クラス】
229

230
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TArray1D<_TItem_>
231

232
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
233

234
/////////////////////////////////////////////////////////////////////// メソッド
235

236
procedure TArray1D<_TItem_>.MakeArray;
237
begin
238
     _ElemsX := _MargsX + _ItemsX + _MargsX;
239

240
     SetLength( _Elems, ElemsN );
241

242
     _OnChange;
243
end;
244

245
function TArray1D<_TItem_>.XtoI( const X_:Integer ) :Integer;
246
begin
247
     Result := _MargsX + X_;
248
end;
249

250
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
251

252
/////////////////////////////////////////////////////////////////////// アクセス
253

254
function TArray1D<_TItem_>.GetItemByte :Integer;
255
begin
256
     Result := SizeOf( _TItem_ );
257
end;
258

259
//------------------------------------------------------------------------------
260

261
function TArray1D<_TItem_>.GetElemsP0 :Pointer;
262
begin
263
     Result := @_Elems[ 0 ];
264
end;
265

266
//------------------------------------------------------------------------------
267

268
function TArray1D<_TItem_>.GetElemsX :Integer;
269
begin
270
     Result := _ElemsX;
271
end;
272

273
function TArray1D<_TItem_>.GetElemsN :Integer;
274
begin
275
     Result := _ElemsX;
276
end;
277

278
function TArray1D<_TItem_>.GetElemsByte :Integer;
279
begin
280
     Result := ItemByte * ElemsN;
281
end;
282

283
//------------------------------------------------------------------------------
284

285
function TArray1D<_TItem_>.GetItems( const X_:Integer ) :_TItem_;
286
begin
287
     Result := _Elems[ XtoI( X_ ) ];
288
end;
289

290
procedure TArray1D<_TItem_>.SetItems( const X_:Integer; const Item_:_TItem_ );
291
begin
292
     _Elems[ XtoI( X_ ) ] := Item_;
293
end;
294

295
function TArray1D<_TItem_>.GetItemP( const X_:Integer ) :_PItem_;
296
begin
297
     Result := @_Elems[ XtoI( X_ ) ];
298
end;
299

300
//------------------------------------------------------------------------------
301

302
function TArray1D<_TItem_>.GetItemsX :Integer;
303
begin
304
     Result := _ItemsX;
305
end;
306

307
procedure TArray1D<_TItem_>.SetItemsX( const ItemsX_:Integer );
308
begin
309
     _ItemsX := ItemsX_;  MakeArray;
310
end;
311

312
function TArray1D<_TItem_>.GetMargsX :Integer;
313
begin
314
     Result := _MargsX;
315
end;
316

317
procedure TArray1D<_TItem_>.SetMargsX( const MargsX_:Integer );
318
begin
319
     _MargsX := MargsX_;  MakeArray;
320
end;
321

322
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
323

324
constructor TArray1D<_TItem_>.Create;
325
begin
326
     Create( 0, 0 );
327
end;
328

329
constructor TArray1D<_TItem_>.Create( const ItemsX_:Integer );
330
begin
331
     Create( ItemsX_, 0 );
332
end;
333

334
constructor TArray1D<_TItem_>.Create( const ItemsX_,MargsX_:Integer );
335
begin
336
     inherited Create;
337

338
     _OnChange := procedure begin end;
339

340
     _ItemsX := ItemsX_;
341
     _MargsX := MargsX_;
342
end;
343

344
procedure TArray1D<_TItem_>.AfterConstruction;
345
begin
346
     MakeArray;
347
end;
348

349
destructor TArray1D<_TItem_>.Destroy;
350
begin
351

352
     inherited;
353
end;
354

355
/////////////////////////////////////////////////////////////////////// メソッド
356

357
class procedure TArray1D<_TItem_>.Swap( var Array0_,Array1_:TArray1D<_TItem_> );
358
var
359
   A :TArray1D<_TItem_>;
360
begin
361
     A := Array0_;  Array0_ := Array1_;  Array1_ := A;
362
end;
363

364
//------------------------------------------------------------------------------
365

366
procedure TArray1D<_TItem_>.MakeEdgeExten;
367
var
368
   M, H, X :Integer;
369
begin
370
     {                                    H
371
                                          |
372
         -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8
373
         ○─○─○─●─●─●─●─●─●─○─○─○
374
         00  00  00  ・  ・  ・  ・  ・  ・  +5  +5  +5   }
375

376
     M := _MargsX  ;
377
     H := _ItemsX-1;
378

379
     for X := 0-M to 0-1 do Items[ X ] := Items[ 0 ];
380
     for X := H+1 to H+M do Items[ X ] := Items[ H ];
381
end;
382

383
//------------------------------------------------------------------------------
384

385
function TArray1D<_TItem_>.AddTail( const Item_:_TItem_ ) :Integer;
386
begin
387
     Result := _ItemsX;
388

389
     Inc( _ItemsX );  MakeArray;
390

391
     Items[ Result ] := Item_;
392
end;
393

394
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TBricArray1D<_TItem_>
395

396
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
397

398
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
399

400
/////////////////////////////////////////////////////////////////////// アクセス
401

402
function TBricArray1D<_TItem_>.GetGridsX :Integer;
403
begin
404
     Result := BricsX + 1;
405
end;
406

407
procedure TBricArray1D<_TItem_>.SetGridsX( const GridsX_:Integer );
408
begin
409
     BricsX := GridsX_ - 1;
410
end;
411

412
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
413

414
/////////////////////////////////////////////////////////////////////// メソッド
415

416
procedure TBricArray1D<_TItem_>.MakeEdgePerio;
417
var
418
   M, N, H, X :Integer;
419
begin
420
     {                                    H   N
421
                                          |   |
422
         -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8
423
       ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
424
         +3  +4  +5  ・  ・  ・  ・  ・  ・  00  +1  +2   }
425

426
     M := _MargsX  ;
427
     N := _ItemsX  ;
428
     H := _ItemsX-1;
429

430
     for X := 0-M to 0-1 do Items[ X ] := Items[ X + N ];
431
     for X := H+1 to H+M do Items[ X ] := Items[ X - N ];
432
end;
433

434
procedure TBricArray1D<_TItem_>.MakeEdgeMirro;
435
var
436
   M, N, H, X :Integer;
437
begin
438
     {                                    H   N
439
                                          |   |
440
         -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8
441
       ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
442
         +2  +1  00  ・  ・  ・  ・  ・  ・  +5  +4  +3   }
443

444
     M := _MargsX  ;
445
     N := _ItemsX  ;
446
     H := _ItemsX-1;
447

448
     for X := 0-M to 0-1 do Items[ X ] := Items[ 0 - X - 1 ];
449
     for X := H+1 to H+M do Items[ X ] := Items[ H - X + N ];
450
end;
451

452
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TGridArray1D<_TItem_>
453

454
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
455

456
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
457

458
/////////////////////////////////////////////////////////////////////// アクセス
459

460
function TGridArray1D<_TItem_>.GetBricsX :Integer;
461
begin
462
     Result := _ItemsX - 1;
463
end;
464

465
procedure TGridArray1D<_TItem_>.SetBricsX( const BricsX_:Integer );
466
begin
467
     _ItemsX := BricsX_ + 1;  MakeArray;
468
end;
469

470
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
471

472
constructor TGridArray1D<_TItem_>.Create( const BricsX_,MargsX_:Integer );
473
begin
474
     inherited Create( BricsX_+1,
475
                       MargsX_   );
476

477
end;
478

479
destructor TGridArray1D<_TItem_>.Destroy;
480
begin
481

482
     inherited;
483
end;
484

485
/////////////////////////////////////////////////////////////////////// メソッド
486

487
procedure TGridArray1D<_TItem_>.MakeEdgePerio;
488
var
489
   M, H, X :Integer;
490
begin
491
     {                                      H
492
                                            |
493
       -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8  +9
494
       ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
495
       +3  +4  +5  ・  ・  ・  ・  ・  ・  00  +1  +2  +3 }
496

497
     M := _MargsX  ;
498
     H := _ItemsX-1;
499

500
     for X := 0-M to 0-1 do Items[ X ] := Items[ X + H ];
501
     for X := H+0 to H+M do Items[ X ] := Items[ X - H ];
502
end;
503

504
procedure TGridArray1D<_TItem_>.MakeEdgeMirro;
505
var
506
   M, H, X :Integer;
507
begin
508
     {                                      H
509
                                            |
510
       -3  -2  -1  00  +1  +2  +3  +4  +5  +6  +7  +8  +9
511
       ┠─╂─╂─┣━╋━╋━╋━╋━╋━┫─╂─╂─┨
512
       +3  +2  +1  ・  ・  ・  ・  ・  ・  ・  +5  +4  +3 }
513

514
     M := _MargsX  ;
515
     H := _ItemsX-1;
516

517
     for X := 0-M to 0-1 do Items[ X ] := Items[ -X       ];
518
     for X := H+1 to H+M do Items[ X ] := Items[ -X + 2*H ];
519
end;
520

521
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TGridMap1D<_TItem_>
522

523
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
524

525
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
526

527
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
528

529
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% TIrreMap1D<_TItem_>
530

531
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& private
532

533
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& protected
534

535
/////////////////////////////////////////////////////////////////////// アクセス
536

537
function TIrreMap1D<_TItem_>.GetMinPosX :Single;
538
begin
539
     Result := Grids[ 0 ].Pos;
540
end;
541

542
function TIrreMap1D<_TItem_>.GetMaxPosX :Single;
543
begin
544
     Result := Grids[ BricsN ].Pos;
545
end;
546

547
//&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& public
548

549
/////////////////////////////////////////////////////////////////////// メソッド
550

551
function TIrreMap1D<_TItem_>.AddTail( const Pos_:Single; const Val_:_TItem_ ) :Integer;
552
begin
553
     Result := AddTail( TPosval1D<_TItem_>.Create( Pos_, Val_ ) );
554
end;
555

556
//------------------------------------------------------------------------------
557

558
function TIrreMap1D<_TItem_>.Insert( const PV_:TPosval1D<_TItem_> ) :Integer;
559
var
560
   H0, I0, I1 :Integer;
561
   G0, G1 :TPosval1D<_TItem_>;
562
begin
563
     H0 := BricsN;  BricsN := BricsN + 1;
564

565
     I1 := BricsN;
566
     for I0 := H0 downto 0 do
567
     begin
568
          G0 := Grids[ I0 ];
569

570
          if G0.Pos <= PV_.Pos then Break;
571

572
          Grids[ I1 ] := G0;
573

574
          I1 := I0;
575
     end;
576

577
     Grids[ I1 ] := PV_;
578

579
     Result := I1;
580
end;
581

582
function TIrreMap1D<_TItem_>.Insert( const Pos_:Single; const Val_:_TItem_ ) :Integer;
583
begin
584
     Result := Insert( TPosval1D<_TItem_>.Create( Pos_, Val_ ) );
585
end;
586

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

589
function TIrreMap1D<_TItem_>.Interp( const I_:Single ) :_TItem_;
590
var
591
   I1 :Integer;
592
   Id :Single;
593
   G0, G1, G2, G3 :_TItem_;
594
begin
595
     I1 := Floor( I_ );  Id := I_ - I1;
596

597
     G0 := Grids[ I1-1 ].Val;
598
     G1 := Grids[ I1   ].Val;
599
     G2 := Grids[ I1+1 ].Val;
600
     G3 := Grids[ I1+2 ].Val;
601

602
     Result := Interp( G0, G1, G2, G3, Id );
603
end;
604

605
function TIrreMap1D<_TItem_>.InterpPos( const Pos_:Single ) :_TItem_;
606
var
607
   G0, G1, G2, G3 :TPosval1D<_TItem_>;
608
   I3 :Integer;
609
begin
610
     G1 := Grids[ -1 ];
611
     G2 := Grids[  0 ];
612
     G3 := Grids[ +1 ];
613
     for I3 := 2 to BricsN+1 do
614
     begin
615
          G0 := G1;  G1 := G2;  G2 := G3;  G3 := Grids[ I3 ];
616

617
          if Pos_ <= G2.Pos then Break;
618
     end;
619

620
     Result := InterpPos( G0, G1, G2, G3, Pos_ );
621
end;
622

623
//$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$【ルーチン】
624

625
//############################################################################## □
626

627
initialization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 初期化
628

629
finalization //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ 最終化
630

631
end. //######################################################################### ■
632