interpolator 0.14 → 0.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. data/interpolator.rb +537 -446
  2. metadata +5 -7
data/interpolator.rb CHANGED
@@ -1,5 +1,5 @@
1
1
  # Copyright (c) 2009 Eric Todd Meyers
2
- #
2
+ #
3
3
  # Permission is hereby granted, free of charge, to any person
4
4
  # obtaining a copy of this software and associated documentation
5
5
  # files (the "Software"), to deal in the Software without
@@ -8,10 +8,10 @@
8
8
  # copies of the Software, and to permit persons to whom the
9
9
  # Software is furnished to do so, subject to the following
10
10
  # conditions:
11
- #
11
+ #
12
12
  # The above copyright notice and this permission notice shall be
13
13
  # included in all copies or substantial portions of the Software.
14
- #
14
+ #
15
15
  # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16
16
  # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
17
17
  # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
@@ -27,501 +27,592 @@
27
27
  #
28
28
  module Interpolator
29
29
 
30
- # Table holds a series of independent and dependent values that can be interpolated or extrapolated.
31
- # The independent values are always floating points numbers. The dependent values can either be floating point
32
- # numbers or themselves Table instances. By nesting the Table in this way a Table of any dimension can be
33
- # created.
34
- #
35
- # Tables can be told to not extrapolate by setting .extrapolate=false
36
- # The interpolation method is controlled with .style = LINEAR, LAGRANGE2, LAGRANGE3, CUBIC (also known as natural spline), or CATMULL (spline)
37
- #
38
- # The style and extrapolate attributes are only applied to that specific Table. They are not propagated to subtables. Each subtable
39
- # can of course accept it's own attributes.
40
- #
41
- # More information, source code and gems @ http://rubyforge.org/projects/interpolator/
42
- #
43
- class Table
44
-
45
- attr_reader :extrapolate,:style
46
- attr_writer :extrapolate,:style
47
-
48
- LINEAR = 1
49
- LAGRANGE2 = 2
50
- LAGRANGE3 = 3
51
- CUBIC = 4
52
- CATMULL = 5
53
- #
54
- # Tables are constructed from either a pair of Arrays or a single Hash.
55
- #
56
- # The 2 argument constructor accepts an array of independents and an array of dependents. The
57
- # independent Array should be floating point values. The dependent Array can be either floating
58
- # point values or Tables (aka sub tables.) There is no limit to how deep a Table can be.
59
- #
60
- # The single argument constructor is similar. The keys of the Hash are the independents. The values
61
- # of the Hash are the dependent values, and can either be floating point numbers or Tables.
62
- #
63
- # Examples
64
- # * simple univariant table
65
- #
66
- # t = Table.new [1.0,2.0],[3.0,4.0]
67
- # and is equivalent to
68
- # t = Table.new(1.0=>3.0,2.0=>4.0)
69
- #
70
- # set attributes inline
71
- # t = Table.new([1.0,2.0],[3.0,4.0]) do |tab| tab.extrapolate=false end
72
- #
73
- # * bivariant table
74
- #
75
- # t = Table.new([1.0,2.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0])])
76
- #
77
- # * trivariant table
78
- #
79
- # t = Table.new(
80
- # 1=>Table.new(
81
- # 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
82
- # 4=>Table.new([11.0,12.0,13.0],[14.0,15.0,16.0]),
83
- # 5=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0])),
84
- # 2=>Table.new(
85
- # 2=>Table.new([1.1,2.0,3.0],[4.0,5.0,6.0]),
86
- # 5=>Table.new([11.0,12.5,13.0],[14.0,15.0,16.0]),
87
- # 6.2=>Table.new([1.0,12.0],[-14.0,-16.0])),
88
- # 8=>Table.new(
89
- # 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
90
- # 5=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0]))
91
- # )
92
- #
93
- # Note: notice how the Hash version of the table constructor makes it easier to view multidimensional Tables.
94
- #
95
- #
96
- # The amount of Table nesting is only limited by RAM.
97
- #
98
- # As a convienance the constructor accepts a block and will pass back the
99
- # Table instance. This makes it easy to set the style and extrapolation inline.
100
- # For example,
101
- #
102
- # tabfoo = Table.new [1,2,3],[4,5.5,6] do |t| t.extrapolate=false end
103
- #
104
- #
105
- def initialize (*args)
106
- if (args.size==2) then
107
- raise "duel argument table constructor must be 2 Arrays" unless args[0].kind_of? Array
108
- raise "duel argument table constructor must be 2 Arrays" unless args[1].kind_of? Array
109
- @inds = args[0] # better be numbers
110
- @deps = args[1] # can either be numbers or sub tables
111
- elsif (args.size == 1) then # hash version
112
- raise "single argument table constructor must be a Hash" unless args[0].kind_of? Hash
113
- # Ruby 1.8 doesnt maintain hash order so lets help it
114
- f = args[0].sort.transpose
115
- @inds = f[0]
116
- @deps = f[1]
117
- else
118
- raise(args.size.to_s + " argument Table constructor not valid");
119
- end
120
-
121
- raise "number of independents must equal the number of dependents" unless @inds.size == @deps.size
122
- ii = nil
123
- @inds.each do |i|
124
- raise "independents must be monotonically increasing" unless (ii == nil || i > ii)
125
- ii = i
126
- end
127
- @extrapolate = true
128
- @style = LINEAR
129
- @ilast = 0 # index of last bracket operation. theory is subsequent table reads may be close to this index so remember it
130
- @secderivs = []
131
- if block_given?
132
- yield self # makes it easy for users to set Table attributes inline
133
- end
134
- end
135
- #
136
- # Interpolate or extrapolate the Table. Pass as many arguments as there are independent dimensions to the table (univariant a
137
- # single argument, bivariant 2 arguments, etc.)
138
- #
139
- # Examples
140
- # * univariant
141
- # t = Table.new [1.0,2.0],[3.0,4.0]
142
- # t.read(1.5) returns 3.5
143
- # * bivariant
144
- # t = Table.new([1.0,2.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0])])
145
- # t.read(2.0,3.0) returns -1.0
146
- # t.read(1.7,2.0) returns 5.4
147
- #
148
- def read(*args)
149
-
150
- raise "table requires at least 2 points for linear interpolation" if (@style == LINEAR && @inds.size<2)
151
- raise "table requires at least 3 points for lagrange2 interpolation" if (@style == LAGRANGE2 && @inds.size<3)
152
- raise "table requires at least 4 points for lagrange3 interpolation" if (@style == LAGRANGE3 && @inds.size<4)
153
- raise "table requires at least 3 points for cubic spline interpolation" if (@style == CUBIC && @inds.size<3)
154
- raise "table requires at least 2 points for catmull-rom interpolation" if (@style == CATMULL && @inds.size<2)
155
- raise "insufficient number of arguments to read table" unless args.size>=1
156
- raise "insufficient number of arguments to read table" if (args.size==1 && @deps[0].kind_of?(Table))
157
- raise "too many arguments to read table" if (args.size>1 && !@deps[0].kind_of?(Table))
158
-
159
- xval = args[0]
160
- subargs = args[1..-1]
161
-
162
- if (@extrapolate == false) && (xval < @inds[0]) then
163
- ans = subread(0,*subargs)
164
-
165
- elsif (@extrapolate == false) && (xval > @inds[-1])
166
- ans = subread(-1,*subargs)
30
+ # Table holds a series of independent and dependent values that can be interpolated or extrapolated.
31
+ # The independent values are always floating points numbers. The dependent values can either be floating point
32
+ # numbers or themselves Table instances. By nesting the Table in this way a Table of any dimension can be
33
+ # created.
34
+ #
35
+ # Tables can be told to not extrapolate by setting .extrapolate=false
36
+ # The interpolation method is controlled with .style = LINEAR, LAGRANGE2, LAGRANGE3, CUBIC (also known as natural spline), or CATMULL (spline)
37
+ #
38
+ # The style and extrapolate attributes are only applied to that specific Table. They are not propagated to subtables. Each subtable
39
+ # can of course accept it's own attributes.
40
+ #
41
+ # More information, source code and gems @ http://rubyforge.org/projects/interpolator/
42
+ #
43
+ class Table
167
44
 
168
- else
169
- ileft = bracket(xval)
170
-
171
- case @style
172
- when LINEAR
173
- x1 = @inds[ileft]
174
- x2 = @inds[ileft+1]
175
- y1 = subread(ileft,*subargs)
176
- y2 = subread(ileft+1,*subargs)
177
- ans = linear(xval,x1,x2,y1,y2)
178
- when LAGRANGE2
179
- indx = ileft
180
- if ileft == @inds.size-2
181
- indx = ileft - 1
182
- end
183
- x1 = @inds[indx]
184
- x2 = @inds[indx+1]
185
- x3 = @inds[indx+2]
186
- y1 = subread(indx,*subargs)
187
- y2 = subread(indx+1,*subargs)
188
- y3 = subread(indx+2,*subargs)
189
- ans = lagrange2(xval,x1,x2,x3,y1,y2,y3)
190
-
191
- when LAGRANGE3
192
- indx = ileft
193
- if (ileft > @inds.size-3)
194
- indx = @inds.size - 3;
195
- elsif (ileft == 0)
196
- indx = ileft + 1
197
- end
198
- x1 = @inds[indx-1]
199
- x2 = @inds[indx]
200
- x3 = @inds[indx+1]
201
- x4 = @inds[indx+2]
202
- y1 = subread(indx-1,*subargs)
203
- y2 = subread(indx,*subargs)
204
- y3 = subread(indx+1,*subargs)
205
- y4 = subread(indx+2,*subargs)
206
- ans = lagrange3(xval,x1,x2,x3,x4,y1,y2,y3,y4)
207
-
208
- when CUBIC
209
- indx = ileft
210
- x1 = @inds[indx]
211
- x2 = @inds[indx+1]
212
- y1 = subread(indx,*subargs)
213
- y2 = subread(indx+1,*subargs)
214
- ans = cubic(xval,indx,x1,x2,y1,y2,*subargs)
215
-
216
- when CATMULL
217
- indx = ileft
218
- tinds = @inds.dup # were gonna prepend and append 2 control points temporarily
219
- tdeps = @deps.dup
220
- tinds.insert(0,@inds[0])
221
- tinds << @inds[-1]
222
- tdeps.insert(0,@deps[0])
223
- tdeps << @deps[-1]
224
- indx=indx+1
225
- x0 = tinds[indx-1]
226
- x1 = tinds[indx]
227
- x2 = tinds[indx+1]
228
- x3 = tinds[indx+2]
229
- y0 = catsubread(indx-1,tdeps,*subargs)
230
- y1 = catsubread(indx,tdeps,*subargs)
231
- y2 = catsubread(indx+1,tdeps,*subargs)
232
- y3 = catsubread(indx+2,tdeps,*subargs)
233
- ans = catmull(xval,x0,x1,x2,x3,y0,y1,y2,y3)
234
-
235
- else
236
- raise("invalid interpolation type")
237
- end
45
+ attr_accessor :extrapolate,:style
46
+
47
+ LINEAR = 1
48
+ LAGRANGE2 = 2
49
+ LAGRANGE3 = 3
50
+ CUBIC = 4
51
+ CATMULL = 5
52
+
53
+ #
54
+ # Tables are constructed from either a pair of Arrays or a single Hash.
55
+ #
56
+ # The 2 argument constructor accepts an array of independents and an array of dependents. The
57
+ # independent Array should be floating point values. The dependent Array can be either floating
58
+ # point values or Tables (aka sub tables.) There is no limit to how deep a Table can be.
59
+ #
60
+ # The single argument constructor is similar. The keys of the Hash are the independents. The values
61
+ # of the Hash are the dependent values, and can either be floating point numbers or Tables.
62
+ #
63
+ # Examples
64
+ # * simple univariant table
65
+ #
66
+ # t = Table.new [1.0,2.0],[3.0,4.0]
67
+ # and is equivalent to
68
+ # t = Table.new(1.0=>3.0,2.0=>4.0)
69
+ #
70
+ # set attributes inline
71
+ # t = Table.new([1.0,2.0],[3.0,4.0]) do |tab| tab.extrapolate=false end
72
+ #
73
+ # * bivariant table
74
+ #
75
+ # t = Table.new([1.0,2.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0])])
76
+ #
77
+ # * trivariant table
78
+ #
79
+ # t = Table.new(
80
+ # 1=>Table.new(
81
+ # 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
82
+ # 4=>Table.new([11.0,12.0,13.0],[14.0,15.0,16.0]),
83
+ # 5=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0])),
84
+ # 2=>Table.new(
85
+ # 2=>Table.new([1.1,2.0,3.0],[4.0,5.0,6.0]),
86
+ # 5=>Table.new([11.0,12.5,13.0],[14.0,15.0,16.0]),
87
+ # 6.2=>Table.new([1.0,12.0],[-14.0,-16.0])),
88
+ # 8=>Table.new(
89
+ # 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
90
+ # 5=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0]))
91
+ # )
92
+ #
93
+ # Note: notice how the Hash version of the table constructor makes it easier to view multidimensional Tables.
94
+ #
95
+ #
96
+ # The amount of Table nesting is only limited by RAM.
97
+ #
98
+ # As a convienance the constructor accepts a block and will pass back the
99
+ # Table instance. This makes it easy to set the style and extrapolation inline.
100
+ # For example,
101
+ #
102
+ # tabfoo = Table.new [1,2,3],[4,5.5,6] do |t| t.extrapolate=false end
103
+ #
104
+ #
105
+ def initialize (*args)
106
+ if (args.size==2) then
107
+ raise "duel argument table constructor must be 2 Arrays" unless args[0].kind_of? Array
108
+ raise "duel argument table constructor must be 2 Arrays" unless args[1].kind_of? Array
109
+ @inds = args[0] # better be numbers
110
+ @deps = args[1] # can either be numbers or sub tables
111
+ elsif (args.size == 1) then # hash version
112
+ raise "single argument table constructor must be a Hash" unless args[0].kind_of? Hash
113
+ # Ruby 1.8 doesnt maintain hash order so lets help it
114
+ f = args[0].sort.transpose
115
+ @inds = f[0]
116
+ @deps = f[1]
117
+ else
118
+ raise(args.size.to_s + " argument Table constructor not valid");
119
+ end
120
+
121
+ raise "number of independents must equal the number of dependents" unless @inds.size == @deps.size
122
+ ii = nil
123
+ @inds.each do |i|
124
+ raise "independents must be monotonically increasing" unless (ii == nil || i > ii)
125
+ ii = i
126
+ end
127
+ @extrapolate = true
128
+ @style = LINEAR
129
+ @ilast = 0 # index of last bracket operation. theory is subsequent table reads may be close to this index so remember it
130
+ @secderivs = []
131
+
132
+ if block_given?
133
+ yield self # makes it easy for users to set Table attributes inline
134
+ end
135
+
136
+ end
137
+ #
138
+ # Interpolate or extrapolate the Table. Pass as many arguments as there are independent dimensions to the table (univariant a
139
+ # single argument, bivariant 2 arguments, etc.)
140
+ #
141
+ # Examples
142
+ # * univariant
143
+ # t = Table.new [1.0,2.0],[3.0,4.0]
144
+ # t.read(1.5) returns 3.5
145
+ # * bivariant
146
+ # t = Table.new([1.0,2.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0])])
147
+ # t.read(2.0,3.0) returns -1.0
148
+ # t.read(1.7,2.0) returns 5.4
149
+ #
150
+ def read(*args)
151
+ raise "table requires at least 2 points for linear interpolation" if (@style == LINEAR && @inds.size<2)
152
+ raise "table requires at least 3 points for lagrange2 interpolation" if (@style == LAGRANGE2 && @inds.size<3)
153
+ raise "table requires at least 4 points for lagrange3 interpolation" if (@style == LAGRANGE3 && @inds.size<4)
154
+ raise "table requires at least 3 points for cubic spline interpolation" if (@style == CUBIC && @inds.size<3)
155
+ raise "table requires at least 2 points for catmull-rom interpolation" if (@style == CATMULL && @inds.size<2)
156
+ raise "insufficient number of arguments to read table" unless args.size>=1
157
+ raise "insufficient number of arguments to read table" if (args.size==1 && @deps[0].kind_of?(Table))
158
+ raise "too many arguments to read table" if (args.size>1 && !@deps[0].kind_of?(Table))
159
+
160
+ xval = args[0]
161
+ subargs = args[1..-1]
162
+
163
+ if (@extrapolate == false) && (xval < @inds[0]) then
164
+ ans = subread(0,*subargs)
165
+ elsif (@extrapolate == false) && (xval > @inds[-1])
166
+ ans = subread(-1,*subargs)
167
+ else
168
+
169
+ ileft = bracket(xval)
170
+
171
+ case @style
172
+ when LINEAR
173
+ x1 = @inds[ileft]
174
+ x2 = @inds[ileft+1]
175
+ y1 = subread(ileft,*subargs)
176
+ y2 = subread(ileft+1,*subargs)
177
+ ans = linear(xval,x1,x2,y1,y2)
178
+
179
+ when LAGRANGE2
180
+ indx = ileft
181
+ if ileft == @inds.size-2
182
+ indx = ileft - 1
238
183
  end
239
- ans
240
- end
241
-
242
- #
243
- # Same as read
244
- #
245
- alias_method :interpolate,:read
246
-
247
- protected
248
-
249
- def subread (i,*subargs)
250
- if subargs == []
251
- @deps[i]
252
- else
253
- @deps[i].read(*subargs)
184
+ x1 = @inds[indx]
185
+ x2 = @inds[indx+1]
186
+ x3 = @inds[indx+2]
187
+ y1 = subread(indx,*subargs)
188
+ y2 = subread(indx+1,*subargs)
189
+ y3 = subread(indx+2,*subargs)
190
+ ans = lagrange2(xval,x1,x2,x3,y1,y2,y3)
191
+
192
+ when LAGRANGE3
193
+ indx = ileft
194
+
195
+ if (ileft > @inds.size-3)
196
+ indx = @inds.size - 3;
197
+ elsif (ileft == 0)
198
+ indx = ileft + 1
254
199
  end
255
- end
256
- def catsubread (i,tdeps,*subargs)
257
- if subargs == []
258
- tdeps[i]
200
+
201
+ x1 = @inds[indx-1]
202
+ x2 = @inds[indx]
203
+ x3 = @inds[indx+1]
204
+ x4 = @inds[indx+2]
205
+ y1 = subread(indx-1,*subargs)
206
+ y2 = subread(indx,*subargs)
207
+ y3 = subread(indx+1,*subargs)
208
+ y4 = subread(indx+2,*subargs)
209
+ ans = lagrange3(xval,x1,x2,x3,x4,y1,y2,y3,y4)
210
+
211
+ when CUBIC
212
+ indx = ileft
213
+ x1 = @inds[indx]
214
+ x2 = @inds[indx+1]
215
+ y1 = subread(indx,*subargs)
216
+ y2 = subread(indx+1,*subargs)
217
+ ans = cubic(xval,indx,x1,x2,y1,y2,*subargs)
218
+
219
+ when CATMULL
220
+ indx = ileft
221
+ tinds = @inds.dup # were gonna prepend and append 2 control points temporarily
222
+ tdeps = @deps.dup
223
+ tinds.insert(0,@inds[0])
224
+ tinds << @inds[-1]
225
+ tdeps.insert(0,@deps[0])
226
+ tdeps << @deps[-1]
227
+ indx = indx+1
228
+ x0 = tinds[indx-1]
229
+ x1 = tinds[indx]
230
+ x2 = tinds[indx+1]
231
+ x3 = tinds[indx+2]
232
+ y0 = catsubread(indx-1,tdeps,*subargs)
233
+ y1 = catsubread(indx,tdeps,*subargs)
234
+ y2 = catsubread(indx+1,tdeps,*subargs)
235
+ y3 = catsubread(indx+2,tdeps,*subargs)
236
+ ans = catmull(xval,x0,x1,x2,x3,y0,y1,y2,y3)
237
+ else
238
+ raise("invalid interpolation type")
239
+ end
240
+ end
241
+ ans
242
+ end
243
+
244
+ #
245
+ # Same as read
246
+ #
247
+ alias_method :interpolate,:read
248
+
249
+ #
250
+ # Human readable form of the Table. Pass a format string for the values to use. The default is %12.4f
251
+ #
252
+ def inspect(format="%12.4f",indent=0)
253
+ indt = " " * indent
254
+ s = ""
255
+ if @deps[0].kind_of? Table
256
+ @inds.each_index do |i|
257
+ s << indt << format % @inds[i]
258
+ s << "\n"
259
+ s << @deps[i].inspect(format,indent+1)
260
+ s << "\n" if i!=(@inds.size-1)
261
+ end
262
+ else
263
+ s << indt
264
+ @inds.each_index do |i|
265
+ s << format % @inds[i]
266
+ end
267
+ s << "\n"
268
+ s << indt
269
+ @deps.each_index do |i|
270
+ s << format % @deps[i]
271
+ end
272
+ end
273
+ s
274
+ end
275
+
276
+ #########
277
+ protected
278
+ #########
279
+
280
+ def subread (i,*subargs)
281
+ if subargs == []
282
+ @deps[i]
283
+ else
284
+ @deps[i].read(*subargs)
285
+ end
286
+ end
287
+
288
+ def catsubread (i,tdeps,*subargs)
289
+ if subargs == []
290
+ tdeps[i]
291
+ else
292
+ tdeps[i].read(*subargs)
293
+ end
294
+ end
295
+
296
+ #
297
+ # high speed bracket via last index and bisection
298
+ #
299
+ def bracket (x)
300
+ if (x<=@inds[0])
301
+ @ilast=0
302
+ elsif (x>=@inds[-2])
303
+ @ilast = @inds.size-2
304
+ else
305
+ low = 0
306
+ high = @inds.size-1
307
+ while !(x>=@inds[@ilast] && x<@inds[@ilast+1])
308
+ if (x>@inds[@ilast])
309
+ low = @ilast + 1
310
+ @ilast = (high - low) / 2 + low
259
311
  else
260
- tdeps[i].read(*subargs)
312
+ high = @ilast - 1
313
+ @ilast = high - (high - low) / 2
261
314
  end
262
- end
315
+ end
316
+ end
317
+ @ilast
318
+ end
263
319
 
320
+ def linear (x,x1,x2,y1,y2)
321
+ r = (y2-y1) / (x2-x1) * (x-x1) + y1
322
+ end
264
323
 
265
- #
266
- # high speed bracket via last index and bisection
267
- #
268
- def bracket (x)
269
- if (x<=@inds[0])
270
- @ilast=0
271
- elsif (x>=@inds[-2])
272
- @ilast = @inds.size-2
273
- else
274
- low = 0
275
- high = @inds.size-1
276
- while !(x>=@inds[@ilast] && x<@inds[@ilast+1])
277
- if (x>@inds[@ilast])
278
- low = @ilast + 1
279
- @ilast = (high - low) / 2 + low
280
- else
281
- high = @ilast - 1
282
- @ilast = high - (high - low) / 2
283
- end
284
- end
285
- end
286
- @ilast
287
- end
288
-
289
- def linear (x,x1,x2,y1,y2)
290
- r = (y2-y1) / (x2-x1) * (x-x1) + y1
291
- end
292
-
293
- def lagrange2(x,x1,x2,x3,y1,y2,y3)
294
- c12 = x1 - x2
295
- c13 = x1 - x3
296
- c23 = x2 - x3
297
- q1 = y1/(c12*c13)
298
- q2 = y2/(c12*c23)
299
- q3 = y3/(c13*c23)
300
- xx1 = x - x1
301
- xx2 = x - x2
302
- xx3 = x - x3
303
- r = xx3*(q1*xx2 - q2*xx1) + q3*xx1*xx2
304
- end
305
-
306
- def lagrange3(x,x1,x2,x3,x4,y1,y2,y3,y4)
307
- c12 = x1 - x2
308
- c13 = x1 - x3
309
- c14 = x1 - x4
310
- c23 = x2 - x3
311
- c24 = x2 - x4
312
- c34 = x3 - x4
313
- q1 = y1/(c12 * c13 * c14)
314
- q2 = y2/(c12 * c23 * c24)
315
- q3 = y3/(c13 * c23 * c34)
316
- q4 = y4/(c14 * c24 * c34)
317
- xx1 = x - x1
318
- xx2 = x - x2
319
- xx3 = x - x3
320
- xx4 = x - x4
321
- r = xx4*(xx3*(q1*xx2 - q2*xx1) + q3*xx1*xx2) - q4*xx1*xx2*xx3
322
- end
323
-
324
- def catmull(xval,x0,x1,x2,x3,y0,y1,y2,y3)
325
- m0 = (y2-y0)/(x2-x0)
326
- m1 = (y3-y1)/(x3-x1)
327
- h = x2-x1
328
- t = (xval - x1)/h
329
- h00 = 2.0*t**3 - 3.0*t**2+1.0
330
- h10 = t**3-2.0*t**2+t
331
- h01 = -2.0*t**3+3.0*t**2
332
- h11 = t**3-t**2
333
- ans = h00*y1+h10*h*m0+h01*y2+h11*h*m1
334
- end
335
-
336
- def cubic(x,indx,x1,x2,y1,y2,*subargs)
337
- if @secderivs == []
338
- @secderivs = second_derivs(*subargs) # this is painful so lets just do it once
339
- end
340
- step = x2 - x1
341
- a = (x2 - x) / step
342
- b = (x - x1) / step
343
- r = a * y1 + b * y2 + ((a*a*a-a) * @secderivs[indx] + (b*b*b-b) * @secderivs[indx+1]) * (step*step) / 6.0
344
- end
345
-
346
- def second_derivs(*subargs)
347
- # natural spline has 0 second derivative at the ends
348
- temp = [0.0]
349
- secder = [0.0]
350
- if subargs.size==0
351
- deps2 = @deps
352
- else
353
- deps2 = @deps.map do |a|
354
- a.read(*subargs)
355
- end
356
- end
357
- 1.upto(@inds.size-2) do |i|
358
- sig = (@inds[i] - @inds[i-1])/(@inds[i+1] - @inds[i-1])
359
- prtl = sig * secder[i-1] + 2.0
360
- secder << (sig-1.0)/prtl
361
- temp << ((deps2[i+1]-deps2[i])/(@inds[i+1]-@inds[i]) - (deps2[i]-deps2[i-1])/(@inds[i]-@inds[i-1]))
362
- temp[i]=(6.0*temp[i]/(@inds[i+1]-@inds[i-1])-sig*temp[i-1])/prtl
363
- end
364
- # natural spline has 0 second derivative at the ends
365
- secder << 0.0
366
- (@inds.size-2).downto(0) do |i|
367
- secder[i]=secder[i]*secder[i+1]+temp[i]
368
- end
369
- secder
370
- end
324
+ def lagrange2(x,x1,x2,x3,y1,y2,y3)
325
+ c12 = x1 - x2
326
+ c13 = x1 - x3
327
+ c23 = x2 - x3
328
+ q1 = y1/(c12*c13)
329
+ q2 = y2/(c12*c23)
330
+ q3 = y3/(c13*c23)
331
+ xx1 = x - x1
332
+ xx2 = x - x2
333
+ xx3 = x - x3
334
+ r = xx3*(q1*xx2 - q2*xx1) + q3*xx1*xx2
371
335
  end
372
336
 
373
- if __FILE__ == $0 then
337
+ def lagrange3(x,x1,x2,x3,x4,y1,y2,y3,y4)
338
+ c12 = x1 - x2
339
+ c13 = x1 - x3
340
+ c14 = x1 - x4
341
+ c23 = x2 - x3
342
+ c24 = x2 - x4
343
+ c34 = x3 - x4
344
+ q1 = y1/(c12 * c13 * c14)
345
+ q2 = y2/(c12 * c23 * c24)
346
+ q3 = y3/(c13 * c23 * c34)
347
+ q4 = y4/(c14 * c24 * c34)
348
+ xx1 = x - x1
349
+ xx2 = x - x2
350
+ xx3 = x - x3
351
+ xx4 = x - x4
352
+ r = xx4*(xx3*(q1*xx2 - q2*xx1) + q3*xx1*xx2) - q4*xx1*xx2*xx3
353
+ end
374
354
 
375
- require 'test/unit'
376
- #
377
- # Unit test for Table class
378
- #
355
+ def catmull(xval,x0,x1,x2,x3,y0,y1,y2,y3)
356
+ m0 = (y2-y0)/(x2-x0)
357
+ m1 = (y3-y1)/(x3-x1)
358
+ h = x2-x1
359
+ t = (xval - x1)/h
360
+ h00 = 2.0*t**3 - 3.0*t**2+1.0
361
+ h10 = t**3-2.0*t**2+t
362
+ h01 = -2.0*t**3+3.0*t**2
363
+ h11 = t**3-t**2
364
+ ans = h00*y1+h10*h*m0+h01*y2+h11*h*m1
365
+ end
366
+
367
+ def cubic(x,indx,x1,x2,y1,y2,*subargs)
368
+ if @secderivs == []
369
+ @secderivs = second_derivs(*subargs) # this is painful so lets just do it once
370
+ end
371
+ step = x2 - x1
372
+ a = (x2 - x) / step
373
+ b = (x - x1) / step
374
+ r = a * y1 + b * y2 + ((a*a*a-a) * @secderivs[indx] + (b*b*b-b) * @secderivs[indx+1]) * (step*step) / 6.0
375
+ end
376
+
377
+ def second_derivs(*subargs)
378
+ # natural spline has 0 second derivative at the ends
379
+ temp = [0.0]
380
+ secder = [0.0]
381
+ if subargs.size==0
382
+ deps2 = @deps
383
+ else
384
+ deps2 = @deps.map do |a|
385
+ a.read(*subargs)
386
+ end
387
+ end
388
+ 1.upto(@inds.size-2) do |i|
389
+ sig = (@inds[i] - @inds[i-1])/(@inds[i+1] - @inds[i-1])
390
+ prtl = sig * secder[i-1] + 2.0
391
+ secder << (sig-1.0)/prtl
392
+ temp << ((deps2[i+1]-deps2[i])/(@inds[i+1]-@inds[i]) - (deps2[i]-deps2[i-1])/(@inds[i]-@inds[i-1]))
393
+ temp[i]=(6.0*temp[i]/(@inds[i+1]-@inds[i-1])-sig*temp[i-1])/prtl
394
+ end
395
+ # natural spline has 0 second derivative at the ends
396
+ secder << 0.0
397
+ (@inds.size-2).downto(0) do |i|
398
+ secder[i]=secder[i]*secder[i+1]+temp[i]
399
+ end
400
+ secder
401
+ end
402
+ end
403
+
404
+ if __FILE__ == $0 then
405
+
406
+ require 'test/unit'
407
+ #
408
+ # Unit test for Table class
409
+ #
379
410
  class TC_LookupTest < Test::Unit::TestCase
380
411
  def setup
381
- @t1 = Table.new [1.0,2.0],[3.0,4.0]
382
- @t2 = Table.new([1.0,2.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0])])
383
- @t3 = Table.new [1.0,2.0],[3.0,4.0]
384
- @t4 = Table.new(
385
- 1.0=>Table.new(
386
- 1.0=>Table.new([1.0,2.0,3.0],
387
- [4.0,5.0,6.0]),
388
- 4.0=>Table.new([11.0,12.0,13.0],
389
- [14.0,15.0,16.0]),
390
- 5.0=>Table.new([11.0,12.0,13.0],
391
- [-14.0,-15.0,-16.0])),
392
- 2.0=>Table.new(
393
- 2.0=>Table.new([1.1,2.0,3.0],
394
- [4.0,5.0,6.0]),
395
- 5.0=>Table.new([11.0,12.5,13.0],
396
- [14.0,15.0,16.0]),
397
- 6.2=>Table.new([1.0,12.0],
398
- [-14.0,-16.0])),
399
- 8.0=>Table.new(
400
- 1.0=>Table.new([1.0,2.0,3.0],
401
- [4.0,5.0,6.0]),
402
- 5.0=>Table.new([11.0,12.0,13.0],
403
- [-14.0,-15.0,-16.0]))
404
- )
405
- @t5 = Table.new [1.0,2.0,3.0],[1.0,4.0,9.0]
406
- @t6 = Table.new [1.0,2.0,3.0,4.0],[1.0,8.0,27.0,64.0]
407
- @t7 = Table.new [0.0,0.8,1.9,3.1,4.2,5.0],[1.0,1.0,1.0,2.0,2.0,2.0]
408
- @t8 = Table.new [0.0,1.0,2.0,3.0,4.0,5.0,6.0],[0.0,0.8415,0.9093,0.1411,-0.7568,-0.9589,-0.2794]
409
- @t9 = Table.new([1.0,2.0,3.0],
410
- [Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0]),Table.new([4.0,5.0,6.0],[7.0,8.0,9.0])])
411
- @t10 = Table.new [1.5,2.0,3.0,4.0],[4.0,5.0,6.0,7.0]
412
+ @t1 = Table.new [1.0,2.0],[3.0,4.0]
413
+ @t2 = Table.new([1.0,2.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0])])
414
+ @t3 = Table.new [1.0,2.0],[3.0,4.0]
415
+ @t4 = Table.new(
416
+ 1.0=>Table.new(
417
+ 1.0=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
418
+ 4.0=>Table.new([11.0,12.0,13.0],[14.0,15.0,16.0]),
419
+ 5.0=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0])),
420
+ 2.0=>Table.new(2.0=>Table.new([1.1,2.0,3.0],[4.0,5.0,6.0]),
421
+ 5.0=>Table.new([11.0,12.5,13.0],[14.0,15.0,16.0]),
422
+ 6.2=>Table.new([1.0,12.0],[-14.0,-16.0])),
423
+ 8.0=>Table.new(
424
+ 1.0=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
425
+ 5.0=>Table.new([11.0,12.0,13.0],[-14.0,-15.0,-16.0])))
426
+ @t5 = Table.new [1.0,2.0,3.0],[1.0,4.0,9.0]
427
+ @t6 = Table.new [1.0,2.0,3.0,4.0],[1.0,8.0,27.0,64.0]
428
+ @t7 = Table.new [0.0,0.8,1.9,3.1,4.2,5.0],[1.0,1.0,1.0,2.0,2.0,2.0]
429
+ @t8 = Table.new [0.0,1.0,2.0,3.0,4.0,5.0,6.0],[0.0,0.8415,0.9093,0.1411,-0.7568,-0.9589,-0.2794]
430
+ @t9 = Table.new([1.0,2.0,3.0],[Table.new([1.0,2.0],[3.0,4.0]),Table.new([2.0,3.0,5.0],[6.0,-1.0,7.0]),Table.new([4.0,5.0,6.0],[7.0,8.0,9.0])])
431
+ @t10 = Table.new [1.5,2.0,3.0,4.0],[4.0,5.0,6.0,7.0]
412
432
  end
413
433
 
414
434
  def test_uni
415
- assert_equal(@t1.read(1.0) , 3.0)
416
- assert_equal(@t1.read(2.0) , 4.0)
417
- assert_equal(@t1.read(1.5) , 3.5)
435
+ assert_equal(@t1.read(1.0) ,3.0)
436
+ assert_equal(@t1.read(2.0) ,4.0)
437
+ assert_equal(@t1.read(1.5) ,3.5)
418
438
  end
439
+
419
440
  def test_bi
420
- assert_equal(@t2.read(1.0,1.0) , 3.0)
421
- assert_equal(@t2.read(2.0,3.0) , -1.0)
422
- assert_equal(@t2.read(1.5,2.0) , 5.0)
441
+ assert_equal(@t2.read(1.0,1.0) , 3.0)
442
+ assert_equal(@t2.read(2.0,3.0) ,-1.0)
443
+ assert_equal(@t2.read(1.5,2.0) , 5.0)
423
444
  end
445
+
424
446
  def test_tri
425
447
  assert_equal(@t4.read(1.5,5,13),0.0)
426
448
  end
449
+
427
450
  def test_create
428
451
  assert_nothing_raised{
429
- Table.new(1.0=>3.0,2.0=>4.0)
452
+ Table.new(1.0=>3.0,2.0=>4.0)
430
453
  }
431
454
  assert_nothing_raised( RuntimeError ){
432
- Table.new 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
433
- 2=>Table.new([2.0,4.0,7.0],[14.0,15.0,16.0])
434
- }
455
+ Table.new(
456
+ 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
457
+ 2=>Table.new([2.0,4.0,7.0],[14.0,15.0,16.0]))
458
+ }
435
459
  assert_nothing_raised( RuntimeError ){
436
- Table.new 1=>Table.new(
437
- [1.0,2.0,3.0],
438
- [4.0,5.0,6.0]),
439
- 2=>Table.new(
440
- [2.0,4.0,7.0],
441
- [14.0,15.0,16.0])
442
- }
460
+ Table.new(
461
+ 1=>Table.new([1.0,2.0,3.0],[4.0,5.0,6.0]),
462
+ 2=>Table.new([2.0,4.0,7.0],[14.0,15.0,16.0]))
463
+ }
443
464
  assert_nothing_raised( RuntimeError ){
444
- Table.new 1=>Table.new(
445
- 1.0=>4.0,
446
- 2.0=>5.0,
447
- 3.0=>6.0),
448
- 2=>Table.new(
449
- [2.0,4.0,7.0,12.0],
450
- [14.0,15.0,16.0,-4.0])
451
- }
452
- assert_raise( RuntimeError ) {Table.new(1,2,3)}
465
+ Table.new 1=>Table.new(1.0=>4.0,2.0=>5.0,3.0=>6.0),2=>Table.new([2.0,4.0,7.0,12.0],[14.0,15.0,16.0,-4.0])
466
+ }
467
+ assert_raise( RuntimeError ) {Table.new(1,2,3)}
453
468
  end
469
+
454
470
  def test_size
455
- @t3.style=Table::LAGRANGE2
456
- assert_raise( RuntimeError ) {@t3.read(1.0)}
457
- @t3.style=Table::LAGRANGE3
458
- assert_raise( RuntimeError ) {@t3.read(1.0)}
459
- @t3.style=Table::CUBIC
460
- assert_raise( RuntimeError ) {@t3.read(1.0)}
461
- @t3.style=Table::LINEAR
462
- assert_nothing_raised( RuntimeError ) {@t3.read(1)}
471
+ @t3.style=Table::LAGRANGE2
472
+ assert_raise( RuntimeError ) {@t3.read(1.0)}
473
+ @t3.style=Table::LAGRANGE3
474
+ assert_raise( RuntimeError ) {@t3.read(1.0)}
475
+ @t3.style=Table::CUBIC
476
+ assert_raise( RuntimeError ) {@t3.read(1.0)}
477
+ @t3.style=Table::LINEAR
478
+ assert_nothing_raised( RuntimeError ) {@t3.read(1)}
463
479
  end
480
+
464
481
  def test_notmono
465
482
  assert_raise( RuntimeError ) {Table.new [1.0,2.0,1.5],[1.0,2.0,3.0]}
466
483
  assert_raise( RuntimeError ) {Table.new [1.0,-2.0,1.5],[1.0,2.0,3.0]}
467
484
  end
485
+
468
486
  def test_extrap
469
487
  @t1.extrapolate = false
470
- assert_equal(@t1.read(0.0) , 3.0)
471
- assert_equal(@t1.read(3.0) , 4.0)
488
+ assert_equal(@t1.read(0.0) , 3.0)
489
+ assert_equal(@t1.read(3.0) , 4.0)
472
490
  @t1.extrapolate = true
473
- assert_equal(@t1.read(0.0) , 2.0)
474
- assert_equal(@t1.read(3.0) , 5.0)
491
+ assert_equal(@t1.read(0.0) , 2.0)
492
+ assert_equal(@t1.read(3.0) , 5.0)
475
493
  end
494
+
476
495
  def test_style
477
- @t5.style=Table::LAGRANGE2
478
- assert_equal(@t5.read(2.0),4.0)
479
- assert_equal(@t5.read(2.5),2.5*2.5)
480
- @t6.style=Table::LAGRANGE3
481
- assert_equal(@t6.read(2.0),8.0)
482
- assert_equal(@t6.read(3.5),3.5*3.5*3.5)
483
- @t5.style=Table::LINEAR
484
- assert_equal(@t5.read(1.5),2.5)
485
- @t6.style=Table::LINEAR
486
- assert_equal(@t6.read(1.5),4.5)
487
- assert_raise( RuntimeError ) {
488
- t = Table.new [1.0,-2.0,1.5],[1.0,2.0,3.0]
489
- t.style=10
490
- t.read(1.0)
491
- }
492
- @t7.style = Table::CUBIC
493
- assert_in_delta(0.93261392,@t7.read(1.2),0.000001)
494
- @t8.style = Table::CUBIC
495
- assert_in_delta(0.59621,@t8.read(2.5),0.000001)
496
- @t9.style = Table::CUBIC
497
- assert_in_delta(8.98175,@t9.read(2.3,1.5),0.000001)
498
- @t10.style=Table::CATMULL
499
- assert_in_delta(3.666666,@t10.read(1.0),0.00001)
500
- assert_in_delta(5.5416666,@t10.read(2.5),0.00001)
501
- assert_in_delta(6.0,@t10.read(0.5),0.00001)
502
- assert_in_delta(8.0,@t10.read(5.0),0.00001)
503
- assert_in_delta(6.5,@t10.read(3.5),0.00001)
504
- assert_in_delta(4.8427,@t10.read(1.9),0.0001)
505
- @t10.extrapolate=false
506
- assert_equal(4.0,@t10.read(1.0))
507
- assert_equal(7.0,@t10.read(99.0))
496
+ @t5.style=Table::LAGRANGE2
497
+ assert_equal(@t5.read(2.0),4.0)
498
+ assert_equal(@t5.read(2.5),2.5*2.5)
499
+ @t6.style=Table::LAGRANGE3
500
+ assert_equal(@t6.read(2.0),8.0)
501
+ assert_equal(@t6.read(3.5),3.5*3.5*3.5)
502
+ @t5.style=Table::LINEAR
503
+ assert_equal(@t5.read(1.5),2.5)
504
+ @t6.style=Table::LINEAR
505
+ assert_equal(@t6.read(1.5),4.5)
506
+ assert_raise( RuntimeError ) {
507
+ t = Table.new [1.0,-2.0,1.5],[1.0,2.0,3.0]
508
+ t.style=10
509
+ t.read(1.0)
510
+ }
511
+ @t7.style = Table::CUBIC
512
+ assert_in_delta(0.93261392,@t7.read(1.2),0.000001)
513
+ @t8.style = Table::CUBIC
514
+ assert_in_delta(0.59621,@t8.read(2.5),0.000001)
515
+ @t9.style = Table::CUBIC
516
+ assert_in_delta(8.98175,@t9.read(2.3,1.5),0.000001)
517
+ @t10.style=Table::CATMULL
518
+ assert_in_delta(3.666666,@t10.read(1.0),0.00001)
519
+ assert_in_delta(5.5416666,@t10.read(2.5),0.00001)
520
+ assert_in_delta(6.0,@t10.read(0.5),0.00001)
521
+ assert_in_delta(8.0,@t10.read(5.0),0.00001)
522
+ assert_in_delta(6.5,@t10.read(3.5),0.00001)
523
+ assert_in_delta(4.8427,@t10.read(1.9),0.0001)
524
+ @t10.extrapolate=false
525
+ assert_equal(4.0,@t10.read(1.0))
526
+ assert_equal(7.0,@t10.read(99.0))
508
527
  end
528
+
509
529
  def test_block
510
530
  t = Table.new [1.0,2.0,3.0],[3.0,4.0,5.0] do |tab| tab.extrapolate=false;tab.style=Table::LAGRANGE2 end
511
531
  assert_equal(t.read(4.0),5.0)
512
532
  end
533
+
513
534
  def test_alias
514
535
  assert_equal(@t1.read(1.5),@t1.interpolate(1.5))
515
536
  end
537
+
516
538
  def test_numargs
517
539
  assert_raise( RuntimeError ) {@t1.read}
518
540
  assert_raise( RuntimeError ) {@t2.read(1.0)}
519
541
  assert_raise( RuntimeError ) {@t2.read(1.0,1.0,1.0)}
520
542
  assert_nothing_raised( RuntimeError ) {@t2.read(1.0,1.0)}
521
543
  end
522
-
544
+ def test_inspect
545
+ s=
546
+ " 1.0000
547
+ 1.0000
548
+ 1.0000 2.0000 3.0000
549
+ 4.0000 5.0000 6.0000
550
+ 4.0000
551
+ 11.0000 12.0000 13.0000
552
+ 14.0000 15.0000 16.0000
553
+ 5.0000
554
+ 11.0000 12.0000 13.0000
555
+ -14.0000 -15.0000 -16.0000
556
+ 2.0000
557
+ 2.0000
558
+ 1.1000 2.0000 3.0000
559
+ 4.0000 5.0000 6.0000
560
+ 5.0000
561
+ 11.0000 12.5000 13.0000
562
+ 14.0000 15.0000 16.0000
563
+ 6.2000
564
+ 1.0000 12.0000
565
+ -14.0000 -16.0000
566
+ 8.0000
567
+ 1.0000
568
+ 1.0000 2.0000 3.0000
569
+ 4.0000 5.0000 6.0000
570
+ 5.0000
571
+ 11.0000 12.0000 13.0000
572
+ -14.0000 -15.0000 -16.0000"
573
+ assert_equal(s,@t4.inspect)
574
+ s=
575
+ " 1.00
576
+ 1.00
577
+ 1.00 2.00 3.00
578
+ 4.00 5.00 6.00
579
+ 4.00
580
+ 11.00 12.00 13.00
581
+ 14.00 15.00 16.00
582
+ 5.00
583
+ 11.00 12.00 13.00
584
+ -14.00 -15.00 -16.00
585
+ 2.00
586
+ 2.00
587
+ 1.10 2.00 3.00
588
+ 4.00 5.00 6.00
589
+ 5.00
590
+ 11.00 12.50 13.00
591
+ 14.00 15.00 16.00
592
+ 6.20
593
+ 1.00 12.00
594
+ -14.00 -16.00
595
+ 8.00
596
+ 1.00
597
+ 1.00 2.00 3.00
598
+ 4.00 5.00 6.00
599
+ 5.00
600
+ 11.00 12.00 13.00
601
+ -14.00 -15.00 -16.00"
602
+ assert_equal(s,@t4.inspect("%8.2f"))
603
+ s=
604
+ " 1.0000
605
+ 1.0000 2.0000
606
+ 3.0000 4.0000
607
+ 2.0000
608
+ 2.0000 3.0000 5.0000
609
+ 6.0000 -1.0000 7.0000"
610
+ assert_equal(s,@t2.inspect)
611
+ s=
612
+ " 1.0000 2.0000
613
+ 3.0000 4.0000"
614
+ assert_equal(s,@t1.inspect)
615
+ end
523
616
  end
524
-
525
- end
526
-
617
+ end
527
618
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: interpolator
3
3
  version: !ruby/object:Gem::Version
4
- version: "0.14"
4
+ version: "0.15"
5
5
  platform: ruby
6
6
  authors:
7
7
  - Eric T Meyers
@@ -9,7 +9,7 @@ autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
11
 
12
- date: 2009-08-15 00:00:00 -04:00
12
+ date: 2009-09-13 00:00:00 -04:00
13
13
  default_executable:
14
14
  dependencies: []
15
15
 
@@ -24,10 +24,8 @@ extra_rdoc_files: []
24
24
  files:
25
25
  - interpolator.rb
26
26
  - LICENSE
27
- has_rdoc: true
27
+ has_rdoc: false
28
28
  homepage: http://interpolator.rubyforge.org/
29
- licenses: []
30
-
31
29
  post_install_message:
32
30
  rdoc_options: []
33
31
 
@@ -48,9 +46,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
48
46
  requirements: []
49
47
 
50
48
  rubyforge_project: interpolator
51
- rubygems_version: 1.3.5
49
+ rubygems_version: 1.3.1
52
50
  signing_key:
53
- specification_version: 3
51
+ specification_version: 2
54
52
  summary: Module Interpolator proves a table class that supports n-dimensional numerical table construction, interpolation and extrapolation. Includes linear, 2nd order and 3rd order lagrange, natural and catmull-rom spline techniques.
55
53
  test_files: []
56
54