figurate_numbers 1.4.0 → 1.4.2

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 (12) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +28 -391
  3. data/docs/ERRATA.md +71 -0
  4. data/docs/METHODS.md +262 -0
  5. data/lib/figurate_numbers/multidimensional_figurate_numbers.rb +540 -551
  6. data/lib/figurate_numbers/p_adic_utils/p_adic_utils.rb +27 -0
  7. data/lib/figurate_numbers/plane_figurate_numbers.rb +420 -394
  8. data/lib/figurate_numbers/space_figurate_numbers.rb +417 -425
  9. data/lib/figurate_numbers/utils/utils.rb +29 -29
  10. data/lib/figurate_numbers/version.rb +3 -1
  11. data/lib/figurate_numbers.rb +4 -6
  12. metadata +9 -7
data/lib/figurate_numbers/multidimensional_figurate_numbers.rb CHANGED
@@ -1,842 +1,831 @@
1
1
  require_relative 'utils/utils'
2
2
 
3
- module MultiDimensionalFigurateNumbers
4
- extend self
5
-
6
- def pentatope
7
- Enumerator.new do |y|
8
- (1..Float::INFINITY).each do |delta|
9
- y << (delta * (delta + 1) * (delta + 2) * (delta + 3)) / 24
3
+ module FigurateNumbers
4
+ # Module containing methods for generating n-dimensional figurate number sequences.
5
+ module MultiDimensionalFigurateNumbers # rubocop:disable Metrics/ModuleLength
6
+ extend self
7
+
8
+ def pentatope
9
+ Enumerator.new do |y|
10
+ (1..Float::INFINITY).each do |delta|
11
+ y << (delta * (delta + 1) * (delta + 2) * (delta + 3)) / 24
12
+ end
10
13
  end
11
14
  end
12
- end
13
-
14
- alias_method :hypertetrahedral, :pentatope
15
- alias_method :triangulotriangular, :pentatope
16
15
 
16
+ alias hypertetrahedral pentatope
17
+ alias triangulotriangular pentatope
17
18
 
18
- def k_dimensional_hypertetrahedron(k)
19
- Enumerator.new do |y|
20
- (1..Float::INFINITY).each do |delta|
21
- y << Utils.rising_factorial(delta, k) / Utils.factorial_iter(k)
19
+ def k_dimensional_hypertetrahedron(k)
20
+ Enumerator.new do |y|
21
+ (1..Float::INFINITY).each do |delta|
22
+ y << Utils.rising_factorial(delta, k) / Utils.factorial_iter(k)
23
+ end
22
24
  end
23
25
  end
24
- end
25
-
26
- alias_method :k_hypertetrahedron, :k_dimensional_hypertetrahedron
27
- alias_method :regular_k_polytopic, :k_dimensional_hypertetrahedron
28
- alias_method :figurate_numbers_of_order_k, :k_dimensional_hypertetrahedron
29
26
 
27
+ alias k_hypertetrahedron k_dimensional_hypertetrahedron
28
+ alias regular_k_polytopic k_dimensional_hypertetrahedron
29
+ alias figurate_numbers_of_order_k k_dimensional_hypertetrahedron
30
30
 
31
- def five_dimensional_hypertetrahedron
32
- Enumerator.new do |y|
33
- (1..Float::INFINITY).each do |delta|
34
- y << Utils.rising_factorial(delta, 5) / Utils.factorial_iter(5)
31
+ def five_dimensional_hypertetrahedron
32
+ Enumerator.new do |y|
33
+ (1..Float::INFINITY).each do |delta|
34
+ y << Utils.rising_factorial(delta, 5) / Utils.factorial_iter(5)
35
+ end
35
36
  end
36
37
  end
37
- end
38
38
 
39
- def six_dimensional_hypertetrahedron
40
- Enumerator.new do |y|
41
- (1..Float::INFINITY).each do |delta|
42
- y << Utils.rising_factorial(delta, 6) / Utils.factorial_iter(6)
39
+ def six_dimensional_hypertetrahedron
40
+ Enumerator.new do |y|
41
+ (1..Float::INFINITY).each do |delta|
42
+ y << Utils.rising_factorial(delta, 6) / Utils.factorial_iter(6)
43
+ end
43
44
  end
44
45
  end
45
- end
46
46
 
47
- def binomial_coefficient_k_dimensional_hypertetrahedron(k)
48
- Enumerator.new do |y|
49
- (1..Float::INFINITY).each do |delta|
50
- y << Utils.binomial_coefficient(delta + (k - 1), k)
47
+ def binomial_coefficient_k_dimensional_hypertetrahedron(k)
48
+ Enumerator.new do |y|
49
+ (1..Float::INFINITY).each do |delta|
50
+ y << Utils.binomial_coefficient(delta + (k - 1), k)
51
+ end
51
52
  end
52
53
  end
53
- end
54
54
 
55
- def biquadratic
56
- Enumerator.new do |y|
57
- (1..Float::INFINITY).each do |delta|
58
- y << delta**4
55
+ def biquadratic
56
+ Enumerator.new do |y|
57
+ (1..Float::INFINITY).each do |delta|
58
+ y << delta**4
59
+ end
59
60
  end
60
61
  end
61
- end
62
62
 
63
- def k_dimensional_hypercube(k)
64
- Enumerator.new do |y|
65
- (1..Float::INFINITY).each do |delta|
66
- y << delta**k
63
+ def k_dimensional_hypercube(k)
64
+ Enumerator.new do |y|
65
+ (1..Float::INFINITY).each do |delta|
66
+ y << delta**k
67
+ end
67
68
  end
68
69
  end
69
- end
70
70
 
71
- alias_method :k_hypercube, :k_dimensional_hypercube
71
+ alias k_hypercube k_dimensional_hypercube
72
72
 
73
- def five_dimensional_hypercube
74
- Enumerator.new do |y|
75
- (1..Float::INFINITY).each do |delta|
76
- y << delta**5
73
+ def five_dimensional_hypercube
74
+ Enumerator.new do |y|
75
+ (1..Float::INFINITY).each do |delta|
76
+ y << delta**5
77
+ end
77
78
  end
78
79
  end
79
- end
80
80
 
81
- def six_dimensional_hypercube
82
- Enumerator.new do |y|
83
- (1..Float::INFINITY).each do |delta|
84
- y << delta**6
81
+ def six_dimensional_hypercube
82
+ Enumerator.new do |y|
83
+ (1..Float::INFINITY).each do |delta|
84
+ y << delta**6
85
+ end
85
86
  end
86
87
  end
87
- end
88
88
 
89
- def hyperoctahedral
90
- Enumerator.new do |y|
91
- (1..Float::INFINITY).each do |delta|
92
- y << (delta**2 * (delta**2 + 2)) / 3
89
+ def hyperoctahedral
90
+ Enumerator.new do |y|
91
+ (1..Float::INFINITY).each do |delta|
92
+ y << (delta**2 * (delta**2 + 2)) / 3
93
+ end
93
94
  end
94
95
  end
95
- end
96
96
 
97
- alias_method :hexadecachoron, :hyperoctahedral
98
- alias_method :four_cross_polytope, :hyperoctahedral
99
- alias_method :four_orthoplex, :hyperoctahedral
97
+ alias hexadecachoron hyperoctahedral
98
+ alias four_cross_polytope hyperoctahedral
99
+ alias four_orthoplex hyperoctahedral
100
100
 
101
- def hypericosahedral
102
- Enumerator.new do |y|
103
- (1..Float::INFINITY).each do |delta|
104
- y << (delta * (145 * delta ** 3 - 280 * delta**2 + 179 * delta - 38)) / 6
101
+ def hypericosahedral
102
+ Enumerator.new do |y|
103
+ (1..Float::INFINITY).each do |delta|
104
+ y << (delta * (145 * delta**3 - 280 * delta**2 + 179 * delta - 38)) / 6
105
+ end
105
106
  end
106
107
  end
107
- end
108
108
 
109
- alias_method :tetraplex, :hypericosahedral
110
- alias_method :polytetrahedron, :hypericosahedral
111
- alias_method :hexacosichoron, :hypericosahedral
109
+ alias tetraplex hypericosahedral
110
+ alias polytetrahedron hypericosahedral
111
+ alias hexacosichoron hypericosahedral
112
112
 
113
- def hyperdodecahedral
114
- Enumerator.new do |y|
115
- (1..Float::INFINITY).each do |delta|
116
- y << (delta * (261 * delta**3 - 504 * delta**2 + 283 * delta - 38)) / 2
113
+ def hyperdodecahedral
114
+ Enumerator.new do |y|
115
+ (1..Float::INFINITY).each do |delta|
116
+ y << (delta * (261 * delta**3 - 504 * delta**2 + 283 * delta - 38)) / 2
117
+ end
117
118
  end
118
119
  end
119
- end
120
120
 
121
- alias_method :hecatonicosachoron, :hyperdodecahedral
122
- alias_method :dodecaplex, :hyperdodecahedral
123
- alias_method :polydodecahedron, :hyperdodecahedral
121
+ alias hecatonicosachoron hyperdodecahedral
122
+ alias dodecaplex hyperdodecahedral
123
+ alias polydodecahedron hyperdodecahedral
124
124
 
125
- def polyoctahedral
126
- Enumerator.new do |y|
127
- (1..Float::INFINITY).each do |delta|
128
- y << delta**2 * (3 * delta**2 - 4 * delta + 2)
125
+ def polyoctahedral
126
+ Enumerator.new do |y|
127
+ (1..Float::INFINITY).each do |delta|
128
+ y << delta**2 * (3 * delta**2 - 4 * delta + 2)
129
+ end
129
130
  end
130
131
  end
131
- end
132
132
 
133
- alias_method :icositetrachoron, :polyoctahedral
134
- alias_method :octaplex, :polyoctahedral
135
- alias_method :hyperdiamond, :polyoctahedral
133
+ alias icositetrachoron polyoctahedral
134
+ alias octaplex polyoctahedral
135
+ alias hyperdiamond polyoctahedral
136
136
 
137
- def four_dimensional_hyperoctahedron
138
- Enumerator.new do |y|
139
- (1..Float::INFINITY).each do |delta|
140
- y << delta**2 * (delta**2 + 2) / 3
137
+ def four_dimensional_hyperoctahedron
138
+ Enumerator.new do |y|
139
+ (1..Float::INFINITY).each do |delta|
140
+ y << delta**2 * (delta**2 + 2) / 3
141
+ end
141
142
  end
142
143
  end
143
- end
144
144
 
145
- def five_dimensional_hyperoctahedron
146
- Enumerator.new do |y|
147
- (1..Float::INFINITY).each do |delta|
148
- y << delta * (2 * delta**4 + 10 * delta**2 + 3) / 15
145
+ def five_dimensional_hyperoctahedron
146
+ Enumerator.new do |y|
147
+ (1..Float::INFINITY).each do |delta|
148
+ y << delta * (2 * delta**4 + 10 * delta**2 + 3) / 15
149
+ end
149
150
  end
150
151
  end
151
- end
152
152
 
153
- def six_dimensional_hyperoctahedron
154
- Enumerator.new do |y|
155
- (1..Float::INFINITY).each do |delta|
156
- y << delta**2 * (2 * delta**4 + 20 * delta**2 + 23) / 45
153
+ def six_dimensional_hyperoctahedron
154
+ Enumerator.new do |y|
155
+ (1..Float::INFINITY).each do |delta|
156
+ y << delta**2 * (2 * delta**4 + 20 * delta**2 + 23) / 45
157
+ end
157
158
  end
158
159
  end
159
- end
160
160
 
161
- def seven_dimensional_hyperoctahedron
162
- Enumerator.new do |y|
163
- (1..Float::INFINITY).each do |delta|
164
- y << (4 * delta**6 + 70 * delta**4 + 196 * delta**2 + 45) * delta / 315
161
+ def seven_dimensional_hyperoctahedron
162
+ Enumerator.new do |y|
163
+ (1..Float::INFINITY).each do |delta|
164
+ y << (4 * delta**6 + 70 * delta**4 + 196 * delta**2 + 45) * delta / 315
165
+ end
165
166
  end
166
167
  end
167
- end
168
168
 
169
- def eight_dimensional_hyperoctahedron
170
- Enumerator.new do |y|
171
- (1..Float::INFINITY).each do |delta|
172
- y << (delta**6 + 28 * delta**4 + 154 * delta**2 + 132) * delta**2 / 315
169
+ def eight_dimensional_hyperoctahedron
170
+ Enumerator.new do |y|
171
+ (1..Float::INFINITY).each do |delta|
172
+ y << (delta**6 + 28 * delta**4 + 154 * delta**2 + 132) * delta**2 / 315
173
+ end
173
174
  end
174
175
  end
175
- end
176
176
 
177
- def nine_dimensional_hyperoctahedron
178
- Enumerator.new do |y|
179
- (1..Float::INFINITY).each do |delta|
180
- y << (2 * delta**8 + 84 * delta**6 + 798 * delta**4 + 1636 * delta**2 + 315) * delta / 2835
177
+ def nine_dimensional_hyperoctahedron # rubocop:disable Metrics/AbcSize
178
+ Enumerator.new do |y|
179
+ (1..Float::INFINITY).each do |delta|
180
+ y << (2 * delta**8 + 84 * delta**6 + 798 * delta**4 + 1636 * delta**2 + 315) * delta / 2835
181
+ end
181
182
  end
182
183
  end
183
- end
184
184
 
185
- def ten_dimensional_hyperoctahedron
186
- Enumerator.new do |y|
187
- (1..Float::INFINITY).each do |delta|
188
- y << (2 * delta**8 + 120 * delta**6 + 1806 * delta**4 + 7180 * delta**2 + 5067) * delta**2 / 14175
185
+ def ten_dimensional_hyperoctahedron # rubocop:disable Metrics/AbcSize
186
+ Enumerator.new do |y|
187
+ (1..Float::INFINITY).each do |delta|
188
+ y << (2 * delta**8 + 120 * delta**6 + 1806 * delta**4 + 7180 * delta**2 + 5067) * delta**2 / 14_175
189
+ end
189
190
  end
190
191
  end
191
- end
192
192
 
193
- def k_dimensional_hyperoctahedron(k)
194
- Enumerator.new do |y|
195
- (1..Float::INFINITY).each do |delta|
196
- a = 0
197
- (0..(k - 1)).each do |i|
198
- a += Utils.binomial_coefficient(k - 1, i) * (Utils.rising_factorial(delta - i, k) / Utils.factorial_iter(k))
193
+ def k_dimensional_hyperoctahedron(k)
194
+ Enumerator.new do |y|
195
+ (1..Float::INFINITY).each do |delta|
196
+ a = 0
197
+ (0..(k - 1)).each do |i|
198
+ a += Utils.binomial_coefficient(k - 1, i) * (Utils.rising_factorial(delta - i, k) / Utils.factorial_iter(k))
199
+ end
200
+ y << a
199
201
  end
200
- y << a
201
202
  end
202
203
  end
203
- end
204
204
 
205
- alias_method :k_cross_polytope, :k_dimensional_hyperoctahedron
205
+ alias k_cross_polytope k_dimensional_hyperoctahedron
206
206
 
207
- def four_dimensional_mgonal_pyramidal(m)
208
- Enumerator.new do |y|
209
- (1..Float::INFINITY).each do |delta|
210
- y << (delta * (delta + 1) * (delta + 2) * ((m - 2) * delta - m + 6)) / 24
207
+ def four_dimensional_mgonal_pyramidal(m)
208
+ Enumerator.new do |y|
209
+ (1..Float::INFINITY).each do |delta|
210
+ y << (delta * (delta + 1) * (delta + 2) * ((m - 2) * delta - m + 6)) / 24
211
+ end
211
212
  end
212
213
  end
213
- end
214
214
 
215
- alias_method :mgonal_pyramidal_numbers_of_the_second_order, :four_dimensional_mgonal_pyramidal
215
+ alias mgonal_pyramidal_numbers_of_the_second_order four_dimensional_mgonal_pyramidal
216
216
 
217
- def four_dimensional_square_pyramidal
218
- Enumerator.new do |y|
219
- (1..Float::INFINITY).each do |delta|
220
- y << (delta * (delta + 1) * (delta + 2) * ((4 - 2) * delta - 4 + 6)) / 24
217
+ def four_dimensional_square_pyramidal
218
+ Enumerator.new do |y|
219
+ (1..Float::INFINITY).each do |delta|
220
+ y << (delta * (delta + 1) * (delta + 2) * ((4 - 2) * delta - 4 + 6)) / 24
221
+ end
221
222
  end
222
223
  end
223
- end
224
224
 
225
- def four_dimensional_pentagonal_pyramidal
226
- Enumerator.new do |y|
227
- (1..Float::INFINITY).each do |delta|
228
- y << (delta * (delta + 1) * (delta + 2) * ((5 - 2) * delta - 5 + 6)) / 24
225
+ def four_dimensional_pentagonal_pyramidal
226
+ Enumerator.new do |y|
227
+ (1..Float::INFINITY).each do |delta|
228
+ y << (delta * (delta + 1) * (delta + 2) * ((5 - 2) * delta - 5 + 6)) / 24
229
+ end
229
230
  end
230
231
  end
231
- end
232
232
 
233
- def four_dimensional_hexagonal_pyramidal
234
- Enumerator.new do |y|
235
- (1..Float::INFINITY).each do |delta|
236
- y << (delta * (delta + 1) * (delta + 2) * ((6 - 2) * delta - 6 + 6)) / 24
233
+ def four_dimensional_hexagonal_pyramidal
234
+ Enumerator.new do |y|
235
+ (1..Float::INFINITY).each do |delta|
236
+ y << (delta * (delta + 1) * (delta + 2) * ((6 - 2) * delta - 6 + 6)) / 24
237
+ end
237
238
  end
238
239
  end
239
- end
240
240
 
241
- def four_dimensional_heptagonal_pyramidal
242
- Enumerator.new do |y|
243
- (1..Float::INFINITY).each do |delta|
244
- y << (delta * (delta + 1) * (delta + 2) * ((7 - 2) * delta - 7 + 6)) / 24
241
+ def four_dimensional_heptagonal_pyramidal
242
+ Enumerator.new do |y|
243
+ (1..Float::INFINITY).each do |delta|
244
+ y << (delta * (delta + 1) * (delta + 2) * ((7 - 2) * delta - 7 + 6)) / 24
245
+ end
245
246
  end
246
247
  end
247
- end
248
248
 
249
- def four_dimensional_octagonal_pyramidal
250
- Enumerator.new do |y|
251
- (1..Float::INFINITY).each do |delta|
252
- y << (delta * (delta + 1) * (delta + 2) * ((8 - 2) * delta - 8 + 6)) / 24
249
+ def four_dimensional_octagonal_pyramidal
250
+ Enumerator.new do |y|
251
+ (1..Float::INFINITY).each do |delta|
252
+ y << (delta * (delta + 1) * (delta + 2) * ((8 - 2) * delta - 8 + 6)) / 24
253
+ end
253
254
  end
254
255
  end
255
- end
256
256
 
257
- def four_dimensional_nonagonal_pyramidal
258
- Enumerator.new do |y|
259
- (1..Float::INFINITY).each do |delta|
260
- y << (delta * (delta + 1) * (delta + 2) * ((9 - 2) * delta - 9 + 6)) / 24
257
+ def four_dimensional_nonagonal_pyramidal
258
+ Enumerator.new do |y|
259
+ (1..Float::INFINITY).each do |delta|
260
+ y << (delta * (delta + 1) * (delta + 2) * ((9 - 2) * delta - 9 + 6)) / 24
261
+ end
261
262
  end
262
263
  end
263
- end
264
264
 
265
- def four_dimensional_decagonal_pyramidal
266
- Enumerator.new do |y|
267
- (1..Float::INFINITY).each do |delta|
268
- y << (delta * (delta + 1) * (delta + 2) * ((10 - 2) * delta - 10 + 6)) / 24
265
+ def four_dimensional_decagonal_pyramidal
266
+ Enumerator.new do |y|
267
+ (1..Float::INFINITY).each do |delta|
268
+ y << (delta * (delta + 1) * (delta + 2) * ((10 - 2) * delta - 10 + 6)) / 24
269
+ end
269
270
  end
270
271
  end
271
- end
272
272
 
273
- def four_dimensional_hendecagonal_pyramidal
274
- Enumerator.new do |y|
275
- (1..Float::INFINITY).each do |delta|
276
- y << (delta * (delta + 1) * (delta + 2) * ((11 - 2) * delta - 11 + 6)) / 24
273
+ def four_dimensional_hendecagonal_pyramidal
274
+ Enumerator.new do |y|
275
+ (1..Float::INFINITY).each do |delta|
276
+ y << (delta * (delta + 1) * (delta + 2) * ((11 - 2) * delta - 11 + 6)) / 24
277
+ end
277
278
  end
278
279
  end
279
- end
280
280
 
281
- def four_dimensional_dodecagonal_pyramidal
282
- Enumerator.new do |y|
283
- (1..Float::INFINITY).each do |delta|
284
- y << (delta * (delta + 1) * (delta + 2) * ((12 - 2) * delta - 12 + 6)) / 24
281
+ def four_dimensional_dodecagonal_pyramidal
282
+ Enumerator.new do |y|
283
+ (1..Float::INFINITY).each do |delta|
284
+ y << (delta * (delta + 1) * (delta + 2) * ((12 - 2) * delta - 12 + 6)) / 24
285
+ end
285
286
  end
286
287
  end
287
- end
288
288
 
289
- def k_dimensional_mgonal_pyramidal(k, m)
290
- Enumerator.new do |y|
291
- (1..Float::INFINITY).each do |n|
292
- y << (Utils.pseudo_pochhammer_function(n, k) * ((m - 2) * n - m + k + 2)) / Utils.factorial_iter(k)
289
+ def k_dimensional_mgonal_pyramidal(k, m)
290
+ Enumerator.new do |y|
291
+ (1..Float::INFINITY).each do |n|
292
+ y << (Utils.pseudo_pochhammer_function(n, k) * ((m - 2) * n - m + k + 2)) / Utils.factorial_iter(k)
293
+ end
293
294
  end
294
295
  end
295
- end
296
296
 
297
- alias_method :mgonal_pyramidal_numbers_of_the_k_2_th_order, :k_dimensional_mgonal_pyramidal
297
+ alias mgonal_pyramidal_numbers_of_the_k_2_th_order k_dimensional_mgonal_pyramidal
298
298
 
299
- def five_dimensional_mgonal_pyramidal(m)
300
- Enumerator.new do |y|
301
- (1..Float::INFINITY).each do |delta|
302
- y << (delta * (delta + 1) * (delta + 2) * (delta + 3) * ((m - 2) * delta - m + 7)) / 120
299
+ def five_dimensional_mgonal_pyramidal(m)
300
+ Enumerator.new do |y|
301
+ (1..Float::INFINITY).each do |delta|
302
+ y << (delta * (delta + 1) * (delta + 2) * (delta + 3) * ((m - 2) * delta - m + 7)) / 120
303
+ end
303
304
  end
304
305
  end
305
- end
306
306
 
307
- def five_dimensional_square_pyramidal
308
- Enumerator.new do |y|
309
- k = 5
310
- m = 4
311
- (1..Float::INFINITY).each do |delta|
312
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
307
+ def five_dimensional_square_pyramidal
308
+ Enumerator.new do |y|
309
+ k = 5
310
+ m = 4
311
+ (1..Float::INFINITY).each do |delta|
312
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
313
+ end
313
314
  end
314
315
  end
315
- end
316
316
 
317
- def five_dimensional_pentagonal_pyramidal
318
- Enumerator.new do |y|
319
- k = 5
320
- m = 5
321
- (1..Float::INFINITY).each do |delta|
322
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
317
+ def five_dimensional_pentagonal_pyramidal
318
+ Enumerator.new do |y|
319
+ k = 5
320
+ m = 5
321
+ (1..Float::INFINITY).each do |delta|
322
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
323
+ end
323
324
  end
324
325
  end
325
- end
326
326
 
327
- def five_dimensional_hexagonal_pyramidal
328
- Enumerator.new do |y|
329
- k = 5
330
- m = 6
331
- (1..Float::INFINITY).each do |delta|
332
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
327
+ def five_dimensional_hexagonal_pyramidal
328
+ Enumerator.new do |y|
329
+ k = 5
330
+ m = 6
331
+ (1..Float::INFINITY).each do |delta|
332
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
333
+ end
333
334
  end
334
335
  end
335
- end
336
336
 
337
- def five_dimensional_heptagonal_pyramidal
338
- Enumerator.new do |y|
339
- k = 5
340
- m = 7
341
- (1..Float::INFINITY).each do |delta|
342
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
337
+ def five_dimensional_heptagonal_pyramidal
338
+ Enumerator.new do |y|
339
+ k = 5
340
+ m = 7
341
+ (1..Float::INFINITY).each do |delta|
342
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
343
+ end
343
344
  end
344
345
  end
345
- end
346
346
 
347
- def five_dimensional_octagonal_pyramidal
348
- Enumerator.new do |y|
349
- k = 5
350
- m = 8
351
- (1..Float::INFINITY).each do |delta|
352
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
347
+ def five_dimensional_octagonal_pyramidal
348
+ Enumerator.new do |y|
349
+ k = 5
350
+ m = 8
351
+ (1..Float::INFINITY).each do |delta|
352
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
353
+ end
353
354
  end
354
355
  end
355
- end
356
356
 
357
- def six_dimensional_mgonal_pyramidal(m)
358
- Enumerator.new do |y|
359
- (1..Float::INFINITY).each do |delta|
360
- y << (delta * (delta + 1) * (delta + 2) * (delta + 3) * (delta + 4) * ((m - 2) * delta - m + 8)) / 720
357
+ def six_dimensional_mgonal_pyramidal(m) # rubocop:disable Metrics/AbcSize
358
+ Enumerator.new do |y|
359
+ (1..Float::INFINITY).each do |delta|
360
+ y << (delta * (delta + 1) * (delta + 2) * (delta + 3) * (delta + 4) * ((m - 2) * delta - m + 8)) / 720
361
+ end
361
362
  end
362
363
  end
363
- end
364
364
 
365
- def six_dimensional_square_pyramidal
366
- Enumerator.new do |y|
367
- k = 6
368
- m = 4
369
- (1..Float::INFINITY).each do |delta|
370
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
365
+ def six_dimensional_square_pyramidal
366
+ Enumerator.new do |y|
367
+ k = 6
368
+ m = 4
369
+ (1..Float::INFINITY).each do |delta|
370
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
371
+ end
371
372
  end
372
373
  end
373
- end
374
374
 
375
- def six_dimensional_pentagonal_pyramidal
376
- Enumerator.new do |y|
377
- k = 6
378
- m = 5
379
- (1..Float::INFINITY).each do |delta|
380
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
375
+ def six_dimensional_pentagonal_pyramidal
376
+ Enumerator.new do |y|
377
+ k = 6
378
+ m = 5
379
+ (1..Float::INFINITY).each do |delta|
380
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
381
+ end
381
382
  end
382
383
  end
383
- end
384
384
 
385
- def six_dimensional_hexagonal_pyramidal
386
- Enumerator.new do |y|
387
- k = 6
388
- m = 6
389
- (1..Float::INFINITY).each do |delta|
390
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
385
+ def six_dimensional_hexagonal_pyramidal
386
+ Enumerator.new do |y|
387
+ k = 6
388
+ m = 6
389
+ (1..Float::INFINITY).each do |delta|
390
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
391
+ end
391
392
  end
392
393
  end
393
- end
394
394
 
395
- def six_dimensional_heptagonal_pyramidal
396
- Enumerator.new do |y|
397
- k = 6
398
- m = 7
399
- (1..Float::INFINITY).each do |delta|
400
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
395
+ def six_dimensional_heptagonal_pyramidal
396
+ Enumerator.new do |y|
397
+ k = 6
398
+ m = 7
399
+ (1..Float::INFINITY).each do |delta|
400
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
401
+ end
401
402
  end
402
403
  end
403
- end
404
404
 
405
- def six_dimensional_octagonal_pyramidal
406
- Enumerator.new do |y|
407
- k = 6
408
- m = 8
409
- (1..Float::INFINITY).each do |delta|
410
- y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
405
+ def six_dimensional_octagonal_pyramidal
406
+ Enumerator.new do |y|
407
+ k = 6
408
+ m = 8
409
+ (1..Float::INFINITY).each do |delta|
410
+ y << (Utils.pseudo_pochhammer_function(delta, k) * ((m - 2) * delta - m + k + 2)) / Utils.factorial_iter(k)
411
+ end
411
412
  end
412
413
  end
413
- end
414
414
 
415
- def centered_biquadratic
416
- Enumerator.new do |y|
417
- a = 0
418
- (1..Float::INFINITY).each do |delta|
419
- a += delta**4 - (delta - 2)**4
420
- y << a + 1
415
+ def centered_biquadratic
416
+ Enumerator.new do |y|
417
+ a = 0
418
+ (1..Float::INFINITY).each do |delta|
419
+ a += delta**4 - (delta - 2)**4
420
+ y << a + 1
421
+ end
421
422
  end
422
423
  end
423
- end
424
424
 
425
- def k_dimensional_centered_hypercube(k)
426
- Enumerator.new do |y|
427
- (1..Float::INFINITY).each do |delta|
428
- y << delta**k + (delta - 1)**k
425
+ def k_dimensional_centered_hypercube(k)
426
+ Enumerator.new do |y|
427
+ (1..Float::INFINITY).each do |delta|
428
+ y << delta**k + (delta - 1)**k
429
+ end
429
430
  end
430
431
  end
431
- end
432
432
 
433
- def five_dimensional_centered_hypercube
434
- Enumerator.new do |y|
435
- (1..Float::INFINITY).each do |delta|
436
- y << delta**5 + (delta - 1)**5
433
+ def five_dimensional_centered_hypercube
434
+ Enumerator.new do |y|
435
+ (1..Float::INFINITY).each do |delta|
436
+ y << delta**5 + (delta - 1)**5
437
+ end
437
438
  end
438
439
  end
439
- end
440
440
 
441
- def six_dimensional_centered_hypercube
442
- Enumerator.new do |y|
443
- (1..Float::INFINITY).each do |delta|
444
- y << delta**6 + (delta - 1)**6
441
+ def six_dimensional_centered_hypercube
442
+ Enumerator.new do |y|
443
+ (1..Float::INFINITY).each do |delta|
444
+ y << delta**6 + (delta - 1)**6
445
+ end
445
446
  end
446
447
  end
447
- end
448
448
 
449
- def centered_polytope
450
- Enumerator.new do |y|
451
- (1..Float::INFINITY).each do |delta|
452
- y << (5 * delta**4 - 10 * delta**3 + 55 * delta**2 - 50 * delta + 24) / 24
449
+ def centered_polytope
450
+ Enumerator.new do |y|
451
+ (1..Float::INFINITY).each do |delta|
452
+ y << (5 * delta**4 - 10 * delta**3 + 55 * delta**2 - 50 * delta + 24) / 24
453
+ end
453
454
  end
454
455
  end
455
- end
456
456
 
457
- def helper_centered_hypertetrahedron(k, n)
458
- return 1 if n == 1
459
- t = Utils.binomial_coefficient(k + 1, k)
460
- return t if n == 2
461
- tau = 0
462
- (0..k-1).each do |i|
463
- tau += Utils.binomial_coefficient(k + 1, k - i) * Utils.binomial_coefficient(n - 2, i)
457
+ def helper_centered_hypertetrahedron(k, n)
458
+ return 1 if n == 1
459
+
460
+ t = Utils.binomial_coefficient(k + 1, k)
461
+ return t if n == 2
462
+
463
+ tau = 0
464
+ (0..k - 1).each do |i|
465
+ tau += Utils.binomial_coefficient(k + 1, k - i) * Utils.binomial_coefficient(n - 2, i)
466
+ end
467
+ tau
464
468
  end
465
- tau
466
- end
467
469
 
468
- def acc_helper_centered_hypertetrahedron(k, n)
469
- a = 0
470
- (1..n).each do |j|
471
- a += helper_centered_hypertetrahedron(k, j)
470
+ def acc_helper_centered_hypertetrahedron(k, n)
471
+ a = 0
472
+ (1..n).each do |j|
473
+ a += helper_centered_hypertetrahedron(k, j)
474
+ end
475
+ a
472
476
  end
473
- a
474
- end
475
477
 
476
- private_class_method :helper_centered_hypertetrahedron
477
- private_class_method :acc_helper_centered_hypertetrahedron
478
+ private_class_method :helper_centered_hypertetrahedron
479
+ private_class_method :acc_helper_centered_hypertetrahedron
478
480
 
479
- def k_dimensional_centered_hypertetrahedron(k)
480
- Enumerator.new do |y|
481
- (1..Float::INFINITY).each do |n|
482
- y << acc_helper_centered_hypertetrahedron(k, n)
481
+ def k_dimensional_centered_hypertetrahedron(k)
482
+ Enumerator.new do |y|
483
+ (1..Float::INFINITY).each do |n|
484
+ y << acc_helper_centered_hypertetrahedron(k, n)
485
+ end
483
486
  end
484
487
  end
485
- end
486
488
 
487
- def five_dimensional_centered_hypertetrahedron
488
- Enumerator.new do |y|
489
- (1..Float::INFINITY).each do |n|
490
- y << acc_helper_centered_hypertetrahedron(5, n)
489
+ def five_dimensional_centered_hypertetrahedron
490
+ Enumerator.new do |y|
491
+ (1..Float::INFINITY).each do |n|
492
+ y << acc_helper_centered_hypertetrahedron(5, n)
493
+ end
491
494
  end
492
495
  end
493
- end
494
496
 
495
- def six_dimensional_centered_hypertetrahedron
496
- Enumerator.new do |y|
497
- (1..Float::INFINITY).each do |n|
498
- y << acc_helper_centered_hypertetrahedron(6, n)
497
+ def six_dimensional_centered_hypertetrahedron
498
+ Enumerator.new do |y|
499
+ (1..Float::INFINITY).each do |n|
500
+ y << acc_helper_centered_hypertetrahedron(6, n)
501
+ end
499
502
  end
500
503
  end
501
- end
502
504
 
503
- def centered_hyperoctahedral
504
- Enumerator.new do |y|
505
- (1..Float::INFINITY).each do |delta|
506
- y << (2 * delta**4 - 4 * delta**3 + 10 * delta**2 - 8 * delta + 3) / 3
505
+ def centered_hyperoctahedral
506
+ Enumerator.new do |y|
507
+ (1..Float::INFINITY).each do |delta|
508
+ y << (2 * delta**4 - 4 * delta**3 + 10 * delta**2 - 8 * delta + 3) / 3
509
+ end
507
510
  end
508
511
  end
509
- end
510
512
 
511
- alias_method :orthoplex, :centered_hyperoctahedral
513
+ alias orthoplex centered_hyperoctahedral
512
514
 
513
- def nexus(k)
514
- Enumerator.new do |y|
515
- (0..Float::INFINITY).each do |delta|
516
- y << (delta + 1)**(k + 1) - delta**(k + 1)
515
+ def nexus(k)
516
+ Enumerator.new do |y|
517
+ (0..Float::INFINITY).each do |delta|
518
+ y << (delta + 1)**(k + 1) - delta**(k + 1)
519
+ end
517
520
  end
518
521
  end
519
- end
520
522
 
521
- def ext_int_double_summation(k, n)
522
- t = ((2**(1)) * Utils.binomial_coefficient(k, 1) * Utils.binomial_coefficient(1, 0))
523
- a = 0
524
- (1..(n - 1)).each do |j|
525
- (0..(k - 1)).each do |i|
526
- a += (2**(1 + i)) * Utils.binomial_coefficient(k, 1 + i) * Utils.binomial_coefficient(j, i)
523
+ def ext_int_double_summation(k, n) # rubocop:disable Metrics/AbcSize
524
+ t = ((2**1) * Utils.binomial_coefficient(k, 1) * Utils.binomial_coefficient(1, 0))
525
+ a = 0
526
+ (1..(n - 1)).each do |j|
527
+ (0..(k - 1)).each do |i|
528
+ a += (2**(1 + i)) * Utils.binomial_coefficient(k, 1 + i) * Utils.binomial_coefficient(j, i)
529
+ end
527
530
  end
531
+ (1 + t + a)
528
532
  end
529
- (1 + t + a)
530
- end
531
533
 
532
- private_class_method :ext_int_double_summation
534
+ private_class_method :ext_int_double_summation
533
535
 
534
- def k_dimensional_centered_hyperoctahedron(k)
535
- Enumerator.new do |y|
536
- y << 1
537
- (1..Float::INFINITY).each do |n|
538
- y << ext_int_double_summation(k, n)
536
+ def k_dimensional_centered_hyperoctahedron(k)
537
+ Enumerator.new do |y|
538
+ y << 1
539
+ (1..Float::INFINITY).each do |n|
540
+ y << ext_int_double_summation(k, n)
541
+ end
539
542
  end
540
543
  end
541
- end
542
544
 
543
- def five_dimensional_centered_hyperoctahedron
544
- Enumerator.new do |y|
545
- y << 1
546
- (1..Float::INFINITY).each do |n|
547
- y << ext_int_double_summation(5, n)
545
+ def five_dimensional_centered_hyperoctahedron
546
+ Enumerator.new do |y|
547
+ y << 1
548
+ (1..Float::INFINITY).each do |n|
549
+ y << ext_int_double_summation(5, n)
550
+ end
548
551
  end
549
552
  end
550
- end
551
553
 
552
- def six_dimensional_centered_hyperoctahedron
553
- Enumerator.new do |y|
554
- y << 1
555
- (1..Float::INFINITY).each do |n|
556
- y << ext_int_double_summation(6, n)
554
+ def six_dimensional_centered_hyperoctahedron
555
+ Enumerator.new do |y|
556
+ y << 1
557
+ (1..Float::INFINITY).each do |n|
558
+ y << ext_int_double_summation(6, n)
559
+ end
557
560
  end
558
561
  end
559
- end
560
562
 
561
- def generalized_pentatope(left_index = 0)
562
- Enumerator.new do |y|
563
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
564
- y << delta * (delta + 1) * (delta + 2) * (delta + 3) / 24
563
+ def generalized_pentatope(left_index = 0)
564
+ Enumerator.new do |y|
565
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
566
+ y << delta * (delta + 1) * (delta + 2) * (delta + 3) / 24
567
+ end
565
568
  end
566
569
  end
567
- end
568
570
 
569
- def generalized_k_dimensional_hypertetrahedron(k, left_index = 0)
570
- Enumerator.new do |y|
571
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
572
- y << Utils.rising_factorial(delta, k) / Utils.factorial_iter(k)
571
+ def generalized_k_dimensional_hypertetrahedron(k, left_index = 0)
572
+ Enumerator.new do |y|
573
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
574
+ y << Utils.rising_factorial(delta, k) / Utils.factorial_iter(k)
575
+ end
573
576
  end
574
577
  end
575
- end
576
578
 
577
- def generalized_biquadratic(left_index = 0)
578
- Enumerator.new do |y|
579
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
580
- y << delta**4
579
+ def generalized_biquadratic(left_index = 0)
580
+ Enumerator.new do |y|
581
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
582
+ y << delta**4
583
+ end
581
584
  end
582
585
  end
583
- end
584
586
 
585
- def generalized_k_dimensional_hypercube(k = 5, left_index = 0)
586
- Enumerator.new do |y|
587
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
588
- y << delta**k
587
+ def generalized_k_dimensional_hypercube(k = 5, left_index = 0)
588
+ Enumerator.new do |y|
589
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
590
+ y << delta**k
591
+ end
589
592
  end
590
593
  end
591
- end
592
594
 
593
- def generalized_hyperoctahedral(left_index = 0)
594
- Enumerator.new do |y|
595
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
596
- y << (delta**2 * (delta**2 + 2)) / 3
595
+ def generalized_hyperoctahedral(left_index = 0)
596
+ Enumerator.new do |y|
597
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
598
+ y << (delta**2 * (delta**2 + 2)) / 3
599
+ end
597
600
  end
598
601
  end
599
- end
600
602
 
601
- def generalized_k_dimensional_hyperoctahedron(k = 5, left_index = 0)
602
- Enumerator.new do |y|
603
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
604
- a = 0
605
- (0..(k - 1)).each do |i|
606
- a += Utils.binomial_coefficient(k - 1, i) * (Utils.rising_factorial(delta - i, k) / Utils.factorial_iter(k))
603
+ def generalized_k_dimensional_hyperoctahedron(k = 5, left_index = 0)
604
+ Enumerator.new do |y|
605
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
606
+ a = 0
607
+ (0..(k - 1)).each do |i|
608
+ a += Utils.binomial_coefficient(k - 1, i) * (Utils.rising_factorial(delta - i, k) / Utils.factorial_iter(k))
609
+ end
610
+ y << a
607
611
  end
608
- y << a
609
612
  end
610
613
  end
611
- end
612
614
 
613
- def generalized_hyperdodecahedral(left_index = 0)
614
- Enumerator.new do |y|
615
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
616
- y << (delta * (261 * delta**3 - 504 * delta**2 + 283 * delta - 38)) / 2
615
+ def generalized_hyperdodecahedral(left_index = 0)
616
+ Enumerator.new do |y|
617
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
618
+ y << (delta * (261 * delta**3 - 504 * delta**2 + 283 * delta - 38)) / 2
619
+ end
617
620
  end
618
621
  end
619
- end
620
622
 
621
- def generalized_hypericosahedral(left_index = 0)
622
- Enumerator.new do |y|
623
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
624
- y << (delta * (145 * delta ** 3 - 280 * delta**2 + 179 * delta - 38)) / 6
623
+ def generalized_hypericosahedral(left_index = 0)
624
+ Enumerator.new do |y|
625
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
626
+ y << (delta * (145 * delta**3 - 280 * delta**2 + 179 * delta - 38)) / 6
627
+ end
625
628
  end
626
629
  end
627
- end
628
630
 
629
- def generalized_polyoctahedral(left_index = 0)
630
- Enumerator.new do |y|
631
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
632
- y << delta**2 * (3 * delta**2 - 4 * delta + 2)
631
+ def generalized_polyoctahedral(left_index = 0)
632
+ Enumerator.new do |y|
633
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
634
+ y << delta**2 * (3 * delta**2 - 4 * delta + 2)
635
+ end
633
636
  end
634
637
  end
635
- end
636
638
 
637
- def generalized_k_dimensional_mgonal_pyramidal(k, m, left_index = 0)
638
- Enumerator.new do |y|
639
- ((-1 * left_index.abs)..Float::INFINITY).each do |n|
640
- y << (Utils.pseudo_pochhammer_function(n, k) * ((m - 2) * n - m + k + 2)) / Utils.factorial_iter(k)
639
+ def generalized_k_dimensional_mgonal_pyramidal(k, m, left_index = 0)
640
+ Enumerator.new do |y|
641
+ ((-1 * left_index.abs)..Float::INFINITY).each do |n|
642
+ y << (Utils.pseudo_pochhammer_function(n, k) * ((m - 2) * n - m + k + 2)) / Utils.factorial_iter(k)
643
+ end
641
644
  end
642
645
  end
643
- end
644
646
 
645
- def generalized_k_dimensional_centered_hypercube(k, left_index = 0)
646
- Enumerator.new do |y|
647
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
648
- y << delta**k + (delta - 1)**k
647
+ def generalized_k_dimensional_centered_hypercube(k, left_index = 0)
648
+ Enumerator.new do |y|
649
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
650
+ y << delta**k + (delta - 1)**k
651
+ end
649
652
  end
650
653
  end
651
- end
652
654
 
653
- def gen_acc_helper_centered_hypertetrahedron(k, n)
654
- a = 0
655
- (1..n.abs).each do |j|
656
- a += helper_centered_hypertetrahedron(k, j)
655
+ def gen_acc_helper_centered_hypertetrahedron(k, n)
656
+ a = 0
657
+ (1..n.abs).each do |j|
658
+ a += helper_centered_hypertetrahedron(k, j)
659
+ end
660
+ n > 0 ? a : -a
657
661
  end
658
- n > 0 ? a : -a
659
- end
660
662
 
661
- private_class_method :gen_acc_helper_centered_hypertetrahedron
663
+ private_class_method :gen_acc_helper_centered_hypertetrahedron
662
664
 
663
- def generalized_k_dimensional_centered_hypertetrahedron(k, left_index = 0)
664
- Enumerator.new do |y|
665
- ((-1 * left_index.abs)..Float::INFINITY).each do |n|
666
- y << gen_acc_helper_centered_hypertetrahedron(k, n)
665
+ def generalized_k_dimensional_centered_hypertetrahedron(k, left_index = 0)
666
+ Enumerator.new do |y|
667
+ ((-1 * left_index.abs)..Float::INFINITY).each do |n|
668
+ y << gen_acc_helper_centered_hypertetrahedron(k, n)
669
+ end
667
670
  end
668
671
  end
669
- end
670
672
 
671
- def gen_ext_int_double_summation(k, n)
672
- is_positive_n = n
673
- n = n.abs
674
- t = ((2) * Utils.binomial_coefficient(k, 1) * Utils.binomial_coefficient(1, 0))
675
- a = 0
676
- (1..(n - 1)).each do |j|
677
- (0..(k - 1)).each do |i|
678
- a += (2**(1 + i)) * Utils.binomial_coefficient(k, 1 + i) * Utils.binomial_coefficient(j, i)
673
+ def gen_ext_int_double_summation(k, n) # rubocop:disable Metrics/AbcSize
674
+ is_positive_n = n
675
+ n = n.abs
676
+ t = (2 * Utils.binomial_coefficient(k, 1) * Utils.binomial_coefficient(1, 0))
677
+ a = 0
678
+ (1..(n - 1)).each do |j|
679
+ (0..(k - 1)).each do |i|
680
+ a += (2**(1 + i)) * Utils.binomial_coefficient(k, 1 + i) * Utils.binomial_coefficient(j, i)
681
+ end
679
682
  end
683
+ is_positive_n > 0 ? (1 + t + a) : (1 + t + a) * -1
680
684
  end
681
- is_positive_n > 0 ? (1 + t + a) : (1 + t + a) * -1
682
- end
683
685
 
684
- private_class_method :gen_ext_int_double_summation
686
+ private_class_method :gen_ext_int_double_summation
685
687
 
686
- def generalized_k_dimensional_centered_hyperoctahedron(k, left_index = 0)
687
- Enumerator.new do |y|
688
- ((-1 * left_index.abs)..Float::INFINITY).each do |n|
689
- y << 1 if n == 1
690
- y << gen_ext_int_double_summation(k, n) if n != 0
688
+ def generalized_k_dimensional_centered_hyperoctahedron(k, left_index = 0)
689
+ Enumerator.new do |y|
690
+ ((-1 * left_index.abs)..Float::INFINITY).each do |n|
691
+ y << 1 if n == 1
692
+ y << gen_ext_int_double_summation(k, n) if n != 0
693
+ end
691
694
  end
692
695
  end
693
- end
694
696
 
695
- def generalized_nexus(k, left_index = 0)
696
- Enumerator.new do |y|
697
- ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
698
- y << (delta + 1)**(k + 1) - delta**(k + 1)
697
+ def generalized_nexus(k, left_index = 0)
698
+ Enumerator.new do |y|
699
+ ((-1 * left_index.abs)..Float::INFINITY).each do |delta|
700
+ y << (delta + 1)**(k + 1) - delta**(k + 1)
701
+ end
699
702
  end
700
703
  end
701
- end
702
704
 
703
- require 'prime'
705
+ require 'prime'
704
706
 
705
- def cuban_numbers
706
- Enumerator.new do |y|
707
- (1..Float::INFINITY).each do |delta|
708
- y << (delta + 1)**3 - delta**3
707
+ def cuban_numbers
708
+ Enumerator.new do |y|
709
+ (1..Float::INFINITY).each do |delta|
710
+ y << (delta + 1)**3 - delta**3
711
+ end
709
712
  end
710
713
  end
711
- end
712
714
 
713
- alias_method :cuban_prime_numbers, :cuban_numbers
715
+ alias cuban_prime_numbers cuban_numbers
714
716
 
715
- def helper_quartan_numbers(delta)
716
- seq = [2]
717
- (1..delta).each do |x|
718
- (x + 1..delta).each do |y|
719
- q = x**4 + y**4
720
- seq << q if Prime.prime?(q)
717
+ def helper_quartan_numbers(delta)
718
+ seq = [2]
719
+ (1..delta).each do |x|
720
+ (x + 1..delta).each do |y|
721
+ q = x**4 + y**4
722
+ seq << q if Prime.prime?(q)
723
+ end
721
724
  end
725
+ seq.sort
722
726
  end
723
- seq.sort
724
- end
725
727
 
726
- private_class_method :helper_quartan_numbers
728
+ private_class_method :helper_quartan_numbers
727
729
 
728
- def quartan_numbers
729
- Enumerator.new do |y|
730
- (1..Float::INFINITY).each do |delta|
731
- y << helper_quartan_numbers(delta)[delta - 1]
730
+ def quartan_numbers
731
+ Enumerator.new do |y|
732
+ (1..Float::INFINITY).each do |delta|
733
+ y << helper_quartan_numbers(delta)[delta - 1]
734
+ end
732
735
  end
733
736
  end
734
- end
735
737
 
736
- def pell_numbers
737
- pell_numbers = [0, 1]
738
- Enumerator.new do |y|
739
- y << 0
740
- y << 1
741
- (2..Float::INFINITY).each do |delta|
742
- y << pell_numbers[delta] = 2 * pell_numbers[delta - 1] + pell_numbers[delta - 2]
738
+ def pell_numbers
739
+ pell_numbers = [0, 1]
740
+ Enumerator.new do |y|
741
+ y << 0
742
+ y << 1
743
+ (2..Float::INFINITY).each do |delta|
744
+ y << pell_numbers[delta] = 2 * pell_numbers[delta - 1] + pell_numbers[delta - 2]
745
+ end
743
746
  end
744
747
  end
745
- end
746
748
 
747
- def is_prime_number(p)
748
- (2..Math.sqrt(p)).none? do |delta|
749
- p % delta == 0
749
+ def prime_number?(p)
750
+ (2..Math.sqrt(p)).none? do |delta|
751
+ p % delta == 0 # rubocop:disable Style/NumericPredicate
752
+ end
750
753
  end
751
- end
752
754
 
753
- def helper_carmichael_number_math_def(n)
754
- if !is_prime_number(n)
755
+ def helper_carmichael_number_math_def(n)
756
+ return if prime_number?(n)
757
+
755
758
  (2..(n - 1)).each do |a|
756
- if n.gcd(a) == 1
757
- if (a.pow(n - 1, n)) != 1
758
- return nil
759
- end
760
- end
759
+ next unless n.gcd(a) == 1
760
+ return nil if a.pow(n - 1, n) != 1
761
761
  end
762
762
  n
763
763
  end
764
- end
765
764
 
766
- def helper_carmichael_number(n)
767
- if !Prime.prime?(n)
768
- (2..(Math.sqrt(n))).each do |a|
769
- if (n).gcd(a) == 1
770
- return if (a.pow(n - 1, n)) != 1
771
- end
765
+ def helper_carmichael_number(n)
766
+ return if Prime.prime?(n)
767
+
768
+ is_carmichael = (2..Math.sqrt(n)).none? do |a|
769
+ n.gcd(a) == 1 && a.pow(n - 1, n) != 1
772
770
  end
773
- n
771
+ is_carmichael ? n : nil
774
772
  end
775
- end
776
773
 
777
- private_class_method :is_prime_number
778
- private_class_method :helper_carmichael_number_math_def
779
- private_class_method :helper_carmichael_number
774
+ private_class_method :prime_number?
775
+ private_class_method :helper_carmichael_number_math_def
776
+ private_class_method :helper_carmichael_number
780
777
 
781
- def carmichael_numbers
782
- Enumerator.new do |y|
783
- (561..Float::INFINITY).each do |delta|
784
- num_seq = helper_carmichael_number(delta)
785
- if num_seq != nil
786
- y << num_seq
778
+ def carmichael_numbers
779
+ Enumerator.new do |y|
780
+ (561..Float::INFINITY).each do |delta|
781
+ num_seq = helper_carmichael_number(delta)
782
+ y << num_seq unless num_seq.nil?
787
783
  end
788
784
  end
789
785
  end
790
- end
791
786
 
792
- def helper_stern_prime_numbers(delta)
793
- prime_list = Prime.first(delta)
794
- q = prime_list[-1]
795
- b = 1
796
- while (2 * b**2) < q
797
- prime_list[0..-2].each do |p|
798
- if q == p + (2 * b**2)
799
- return nil
787
+ def helper_stern_prime_numbers(delta)
788
+ prime_list = Prime.first(delta)
789
+ q = prime_list[-1]
790
+ b = 1
791
+ while (2 * b**2) < q
792
+ prime_list[0..-2].each do |p|
793
+ return nil if q == p + (2 * b**2)
800
794
  end
795
+ b += 1
801
796
  end
802
- b += 1
797
+ q
803
798
  end
804
- q
805
- end
806
799
 
807
- private_class_method :helper_stern_prime_numbers
800
+ private_class_method :helper_stern_prime_numbers
808
801
 
809
- def stern_prime_numbers(infty = false)
810
- Enumerator.new do |y|
811
- max_term = infty == false ? 238 : float::INFINITY
812
- (1..max_term).each do |delta|
813
- num_seq = helper_stern_prime_numbers(delta)
814
- if num_seq != nil
815
- y << num_seq
802
+ def stern_prime_numbers(infty = false) # rubocop:disable Style/OptionalBooleanParameter
803
+ Enumerator.new do |y|
804
+ max_term = infty == false ? 238 : float::INFINITY
805
+ (1..max_term).each do |delta|
806
+ num_seq = helper_stern_prime_numbers(delta)
807
+ y << num_seq unless num_seq.nil?
816
808
  end
817
809
  end
818
810
  end
819
- end
820
811
 
821
- def helper_apocalyptic_numbers(delta)
822
- search_666 = (2**delta).to_s
823
- len_666 = search_666.length - 1
824
- (0..len_666).each do |index|
825
- if search_666[index, 3] == '666' && search_666[index + 1] == '6' && search_666[index + 2] == '6'
826
- return delta
812
+ def helper_apocalyptic_numbers(delta)
813
+ search_666 = (2**delta).to_s # rubocop:disable Naming/VariableNumber
814
+ len_666 = search_666.length - 1 # rubocop:disable Naming/VariableNumber
815
+ (0..len_666).each do |index|
816
+ return delta if search_666[index, 3] == '666' && search_666[index + 1] == '6' && search_666[index + 2] == '6'
827
817
  end
818
+ nil
828
819
  end
829
- nil
830
- end
831
820
 
832
- private_class_method :helper_apocalyptic_numbers
821
+ private_class_method :helper_apocalyptic_numbers
833
822
 
834
- def apocalyptic_numbers
835
- Enumerator.new do |y|
836
- (157..Float::INFINITY).each do |delta|
837
- y << helper_apocalyptic_numbers(delta) if helper_apocalyptic_numbers(delta) != nil
823
+ def apocalyptic_numbers
824
+ Enumerator.new do |y|
825
+ (157..Float::INFINITY).each do |delta|
826
+ y << helper_apocalyptic_numbers(delta) unless helper_apocalyptic_numbers(delta).nil?
827
+ end
838
828
  end
839
829
  end
840
830
  end
841
-
842
831
  end