friendly_extensions 0.0.61 → 0.0.62
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +4 -4
- data/lib/alphanumeric.rb +23 -2
- data/lib/alphanumeric.rb.orig +84 -0
- data/lib/array.rb +90 -15
- data/lib/array.rb.orig +313 -0
- data/lib/nil_class.rb +3 -0
- data/lib/numbers.rb +29 -31
- data/lib/numbers.rb.orig +220 -0
- data/lib/smart_currency.rb +4 -2
- data/lib/smart_currency.rb.orig +74 -0
- data/lib/string_and_more.rb +20 -20
- data/lib/string_and_more.rb.orig +303 -0
- data/test/array_test.rb +24 -2
- data/test/array_test.rb.orig +221 -0
- data/test/numeric_test.rb +11 -1
- data/test/numeric_test.rb.orig +94 -0
- metadata +15 -6
checksums.yaml
CHANGED
@@ -1,7 +1,7 @@
|
|
1
1
|
---
|
2
2
|
SHA1:
|
3
|
-
metadata.gz:
|
4
|
-
data.tar.gz:
|
3
|
+
metadata.gz: ff2c7ed3b7ba8d409f8ca14d3cbf0f168fc7a633
|
4
|
+
data.tar.gz: c240211d83e278a198fb710393ea1f3368f4495a
|
5
5
|
SHA512:
|
6
|
-
metadata.gz:
|
7
|
-
data.tar.gz:
|
6
|
+
metadata.gz: 4b0a21c79bfeb6506dda677f9143e8e12d06561702fd2cf47ddd7f464e2445d83ca670a350bd6cec774e068812d84ed9bd54a363d400f09573e70d3f142ec2aa
|
7
|
+
data.tar.gz: 39ab444b280dae8877f3571ca4c4d8779e6b3030c5731b636f3f15b3c48b6b7bdcfcc54075d6fa9c5d4d688acd6a2d08b2b2adb7851f547c5b6af98aa3efa63e
|
data/lib/alphanumeric.rb
CHANGED
@@ -3,6 +3,10 @@ module Alphanumeric
|
|
3
3
|
|
4
4
|
# Give every year a letter
|
5
5
|
# TODO: should be automatically computed
|
6
|
+
LETTERS = "abcdefghijklmnopqrstuvwxyz".upcase.split('')
|
7
|
+
|
8
|
+
START_YEAR = 1960
|
9
|
+
|
6
10
|
YEAR_LETTERS = {
|
7
11
|
2009 => "A",
|
8
12
|
2010 => "B",
|
@@ -48,8 +52,25 @@ module Alphanumeric
|
|
48
52
|
2050 => "PA",
|
49
53
|
}
|
50
54
|
|
51
|
-
def self.year_letter(year=Time.now.year)
|
52
|
-
|
55
|
+
def self.year_letter(year=Time.now.year, letters = LETTERS)
|
56
|
+
|
57
|
+
steps = []
|
58
|
+
|
59
|
+
d = (year - START_YEAR)
|
60
|
+
n = d.fdiv(letters.size).ceil
|
61
|
+
string = ""
|
62
|
+
|
63
|
+
n.times do |i|
|
64
|
+
# First
|
65
|
+
if i == 0
|
66
|
+
string << letters[d%letters.size]
|
67
|
+
else
|
68
|
+
x = d.fdiv(letters.size*(i+1)).round
|
69
|
+
string << letters[x]
|
70
|
+
end
|
71
|
+
end
|
72
|
+
|
73
|
+
return string
|
53
74
|
end
|
54
75
|
|
55
76
|
end
|
@@ -0,0 +1,84 @@
|
|
1
|
+
# -*- encoding : utf-8 -*-
|
2
|
+
module Alphanumeric
|
3
|
+
|
4
|
+
# Give every year a letter
|
5
|
+
# TODO: should be automatically computed
|
6
|
+
<<<<<<< HEAD
|
7
|
+
LETTERS = "abcdefghijklmnopqrstuvwxyz".upcase.split('')
|
8
|
+
|
9
|
+
START_YEAR = 1960
|
10
|
+
|
11
|
+
=======
|
12
|
+
>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
|
13
|
+
YEAR_LETTERS = {
|
14
|
+
2009 => "A",
|
15
|
+
2010 => "B",
|
16
|
+
2011 => "C",
|
17
|
+
2012 => "D",
|
18
|
+
2013 => "E",
|
19
|
+
2014 => "F",
|
20
|
+
2015 => "G",
|
21
|
+
2016 => "H",
|
22
|
+
2017 => "I",
|
23
|
+
2018 => "J",
|
24
|
+
2019 => "K",
|
25
|
+
2020 => "L",
|
26
|
+
2021 => "M",
|
27
|
+
2022 => "N",
|
28
|
+
2023 => "O",
|
29
|
+
2024 => "P",
|
30
|
+
2025 => "Q",
|
31
|
+
2026 => "R",
|
32
|
+
2027 => "S",
|
33
|
+
2028 => "T",
|
34
|
+
2029 => "U",
|
35
|
+
2030 => "V",
|
36
|
+
2031 => "W",
|
37
|
+
2032 => "X",
|
38
|
+
2033 => "Y",
|
39
|
+
2034 => "Z",
|
40
|
+
2035 => "AA",
|
41
|
+
2036 => "BA",
|
42
|
+
2037 => "CA",
|
43
|
+
2038 => "DA",
|
44
|
+
2039 => "EA",
|
45
|
+
2040 => "FA",
|
46
|
+
2041 => "GA",
|
47
|
+
2042 => "HA",
|
48
|
+
2043 => "IA",
|
49
|
+
2044 => "JA",
|
50
|
+
2045 => "KA",
|
51
|
+
2046 => "LA",
|
52
|
+
2047 => "MA",
|
53
|
+
2048 => "NA",
|
54
|
+
2049 => "OA",
|
55
|
+
2050 => "PA",
|
56
|
+
}
|
57
|
+
|
58
|
+
<<<<<<< HEAD
|
59
|
+
def self.year_letter(year=Time.now.year, letters = LETTERS)
|
60
|
+
|
61
|
+
steps = []
|
62
|
+
|
63
|
+
d = (year - START_YEAR)
|
64
|
+
n = d.fdiv(letters.size).ceil
|
65
|
+
string = ""
|
66
|
+
|
67
|
+
n.times do |i|
|
68
|
+
# First
|
69
|
+
if i == 0
|
70
|
+
string << letters[d%letters.size]
|
71
|
+
else
|
72
|
+
x = d.fdiv(letters.size*(i+1)).round
|
73
|
+
string << letters[x]
|
74
|
+
end
|
75
|
+
end
|
76
|
+
|
77
|
+
return string
|
78
|
+
=======
|
79
|
+
def self.year_letter(year=Time.now.year)
|
80
|
+
YEAR_LETTERS[year]
|
81
|
+
>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
|
82
|
+
end
|
83
|
+
|
84
|
+
end
|
data/lib/array.rb
CHANGED
@@ -16,20 +16,20 @@ module ArrayExt
|
|
16
16
|
# Get avg. value from, either from numeric values or from
|
17
17
|
# values from a object included in array
|
18
18
|
def avg(attribute = nil)
|
19
|
-
|
19
|
+
value = self
|
20
20
|
if attribute.nil?
|
21
|
-
|
22
|
-
|
21
|
+
value.delete(nil)
|
22
|
+
value = self.map {|r| r.to_f }
|
23
23
|
else
|
24
|
-
|
24
|
+
value = self
|
25
25
|
# Bei fehlerhaften attribute wird nil gespeichert
|
26
|
-
|
26
|
+
value = value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
|
27
27
|
# Leere Werte löschen
|
28
|
-
|
28
|
+
value.delete(nil)
|
29
29
|
end
|
30
|
-
# Divide by zero
|
31
|
-
|
32
|
-
|
30
|
+
# Divide by zero ausschließen
|
31
|
+
value.size == 0 ? size = 1 : size = value.size
|
32
|
+
value.sum / size
|
33
33
|
end
|
34
34
|
|
35
35
|
|
@@ -134,15 +134,15 @@ module ArrayExt
|
|
134
134
|
|
135
135
|
# break array into n arrays
|
136
136
|
def seperate(n = 8)
|
137
|
-
|
137
|
+
f = n
|
138
138
|
aks_size = self.size
|
139
|
-
rest = aks_size %
|
139
|
+
rest = aks_size % f
|
140
140
|
|
141
|
-
|
141
|
+
stack = ((aks_size - rest) / f)
|
142
142
|
|
143
|
-
arrays = (1
|
143
|
+
arrays = (1..f).to_a
|
144
144
|
|
145
|
-
arrays.map! {|i| self.first(
|
145
|
+
arrays.map! {|i| self.first(stack*i).last(stack) }
|
146
146
|
arrays[-1] += self.last(rest) if rest != 0
|
147
147
|
#arrays.last.pop if (arrays.last.last.empty? || arrays.last.last.blank?)
|
148
148
|
return arrays
|
@@ -199,7 +199,82 @@ module ArrayExt
|
|
199
199
|
else
|
200
200
|
self.join(sep)
|
201
201
|
end
|
202
|
-
end
|
202
|
+
end
|
203
|
+
|
204
|
+
|
205
|
+
def interpolate(filtered_value = nil, options = {})
|
206
|
+
begin
|
207
|
+
|
208
|
+
int_start_value = nil
|
209
|
+
int_end_value = nil
|
210
|
+
int_from = 0
|
211
|
+
int_to = 0
|
212
|
+
int_steps = 0
|
213
|
+
|
214
|
+
array_with_interpolation = []
|
215
|
+
|
216
|
+
self.each_with_index do |x,i|
|
217
|
+
if i > 0
|
218
|
+
if x != filtered_value
|
219
|
+
# Wenn der letze ein fehler war ist die strecke zuende
|
220
|
+
if self[i-1] == filtered_value
|
221
|
+
|
222
|
+
if i-1 == 0
|
223
|
+
# Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
|
224
|
+
#
|
225
|
+
m = (self[i+1]-x)
|
226
|
+
|
227
|
+
array_with_interpolation[0] = x-m
|
228
|
+
array_with_interpolation << x
|
229
|
+
|
230
|
+
else
|
231
|
+
int_end_value = x
|
232
|
+
int_to = i
|
233
|
+
|
234
|
+
# Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
|
235
|
+
m = (int_end_value-int_start_value).fdiv((int_to-int_from))
|
236
|
+
|
237
|
+
# Fülle fehlende werte mit werten (y = mx + b)
|
238
|
+
int_steps.times {|mi| array_with_interpolation << (int_start_value+((mi+1)*m)) }
|
239
|
+
array_with_interpolation << int_end_value
|
240
|
+
|
241
|
+
# Reset all values
|
242
|
+
int_start_value = int_end_value
|
243
|
+
int_end_value = nil
|
244
|
+
int_from = 0
|
245
|
+
int_to = 0
|
246
|
+
int_steps = 0
|
247
|
+
puts array_with_interpolation.inspect
|
248
|
+
end
|
249
|
+
else
|
250
|
+
int_start_value = x
|
251
|
+
array_with_interpolation << x
|
252
|
+
end
|
253
|
+
# Wenn letzer wert fehlerhaft
|
254
|
+
elsif i == self.size-1 && x == filtered_value
|
255
|
+
# Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
|
256
|
+
# Berechnung über gesamtes array
|
257
|
+
m = (array_with_interpolation.last-array_with_interpolation.first).fdiv(array_with_interpolation.size-1)
|
258
|
+
array_with_interpolation << (array_with_interpolation.last+m)
|
259
|
+
else
|
260
|
+
int_steps += 1
|
261
|
+
int_from = i-int_steps
|
262
|
+
end
|
263
|
+
|
264
|
+
else
|
265
|
+
int_start_value = x
|
266
|
+
array_with_interpolation << x
|
267
|
+
end
|
268
|
+
|
269
|
+
end
|
270
|
+
|
271
|
+
return array_with_interpolation
|
272
|
+
rescue
|
273
|
+
puts "WARNING: Interpolation not possible!".red
|
274
|
+
return self
|
275
|
+
end
|
276
|
+
|
277
|
+
end
|
203
278
|
|
204
279
|
end
|
205
280
|
end
|
data/lib/array.rb.orig
ADDED
@@ -0,0 +1,313 @@
|
|
1
|
+
# -*- encoding : utf-8 -*-
|
2
|
+
# Add the methods to the Array Class
|
3
|
+
module ArrayExt
|
4
|
+
Array.class_eval do
|
5
|
+
|
6
|
+
# Use sum from Activesupport
|
7
|
+
# Sum is not a default in Ruby
|
8
|
+
def sum(identity = 0, &block)
|
9
|
+
if block_given?
|
10
|
+
map(&block).sum(identity)
|
11
|
+
else
|
12
|
+
inject { |sum, element| sum + element } || identity
|
13
|
+
end
|
14
|
+
end
|
15
|
+
|
16
|
+
# Get avg. value from, either from numeric values or from
|
17
|
+
# values from a object included in array
|
18
|
+
def avg(attribute = nil)
|
19
|
+
<<<<<<< HEAD
|
20
|
+
value = self
|
21
|
+
if attribute.nil?
|
22
|
+
value.delete(nil)
|
23
|
+
value = self.map {|r| r.to_f }
|
24
|
+
else
|
25
|
+
value = self
|
26
|
+
# Bei fehlerhaften attribute wird nil gespeichert
|
27
|
+
value = value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
|
28
|
+
# Leere Werte löschen
|
29
|
+
value.delete(nil)
|
30
|
+
end
|
31
|
+
# Divide by zero ausschließen
|
32
|
+
value.size == 0 ? size = 1 : size = value.size
|
33
|
+
value.sum / size
|
34
|
+
=======
|
35
|
+
@value = self
|
36
|
+
if attribute.nil?
|
37
|
+
@value.delete(nil)
|
38
|
+
@value = self.map {|r| r.to_f }
|
39
|
+
else
|
40
|
+
@value = self
|
41
|
+
# Bei fehlerhaften attribute wird nil gespeichert
|
42
|
+
@value = @value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
|
43
|
+
# Leere Werte löschen
|
44
|
+
@value.delete(nil)
|
45
|
+
end
|
46
|
+
# Divide by zero ausschließen
|
47
|
+
@value.size == 0 ? size = 1 : size = @value.size
|
48
|
+
@value.sum / size
|
49
|
+
>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
|
50
|
+
end
|
51
|
+
|
52
|
+
|
53
|
+
|
54
|
+
# Generate a hash with the given array elements as keys and 'init_value' as value
|
55
|
+
def array_to_hash(init_val = 0)
|
56
|
+
h = {}
|
57
|
+
self.each {|x| h.merge!(x => init_val) unless x.nil? }
|
58
|
+
return h
|
59
|
+
end
|
60
|
+
|
61
|
+
|
62
|
+
def to_structured_hash(attribute, options = {})
|
63
|
+
data = {}
|
64
|
+
|
65
|
+
self.each do |item|
|
66
|
+
if attribute.is_a?(Symbol) && options[:load_from_hash] != true
|
67
|
+
key = item.send(attribute) rescue ""
|
68
|
+
elsif attribute.is_a?(Symbol) && options[:load_from_hash] == true
|
69
|
+
key = item[attribute] rescue ""
|
70
|
+
elsif attribute.is_a?(String)
|
71
|
+
attribute_methods = attribute.split(".")
|
72
|
+
key = item.send(attribute_methods[0])
|
73
|
+
attribute_methods[1..-1].each do |x|
|
74
|
+
key = key.send(x) rescue ""
|
75
|
+
end
|
76
|
+
end
|
77
|
+
|
78
|
+
if data[key].nil?
|
79
|
+
data.merge!(key => [item])
|
80
|
+
else
|
81
|
+
data[key] << item
|
82
|
+
end
|
83
|
+
end
|
84
|
+
|
85
|
+
return data
|
86
|
+
end
|
87
|
+
|
88
|
+
|
89
|
+
# Sum up an array of objects with given attirbute
|
90
|
+
# Attributes can be given as symbol (:my_value will return obj.my_value)
|
91
|
+
# or as string ("user.my_value" will return my_value from user object which belongs to object in array)
|
92
|
+
# also, options could be passed, which could be *args or options hash
|
93
|
+
def sum_with_attribute(arg, opt =nil)
|
94
|
+
if arg.nil?
|
95
|
+
return self.compact.sum
|
96
|
+
else
|
97
|
+
values = []
|
98
|
+
if arg.is_a?(Symbol)
|
99
|
+
self.map {|i| ((opt.nil? ? i.send(arg) : i.send(arg, opt)) rescue 0) }.sum
|
100
|
+
elsif arg.is_a?(String)
|
101
|
+
self.each do |v|
|
102
|
+
tag_methods = arg.split(".")
|
103
|
+
tagx = v.send(tag_methods[0])
|
104
|
+
tag_methods[1..-1].each do |x|
|
105
|
+
# Use options if last method in chain called
|
106
|
+
if tag_methods[1..-1].last == x && !opt.nil?
|
107
|
+
tagx = tagx.send(x,opt)
|
108
|
+
else
|
109
|
+
tagx = tagx.send(x)
|
110
|
+
end
|
111
|
+
end
|
112
|
+
values << tagx
|
113
|
+
end
|
114
|
+
return values.compact.sum
|
115
|
+
end
|
116
|
+
end
|
117
|
+
end
|
118
|
+
|
119
|
+
|
120
|
+
# check the number of items included in the array
|
121
|
+
def count_for(item)
|
122
|
+
count = 0
|
123
|
+
self.each {|x| count += 1 if x == item}
|
124
|
+
return count
|
125
|
+
end
|
126
|
+
|
127
|
+
|
128
|
+
# return the item after the given val in array
|
129
|
+
# returns val if no item found or val is not included
|
130
|
+
# toggle :cycle => true to continue search at beginn of array if end is reached
|
131
|
+
def next(val, options = {})
|
132
|
+
i = self.index(val)
|
133
|
+
return val if i.nil?
|
134
|
+
|
135
|
+
i == self.size-1 ?
|
136
|
+
(options[:cycle] == true ? self.first : val) : self[i+1]
|
137
|
+
end
|
138
|
+
|
139
|
+
|
140
|
+
# Schnittmenge / Intersection zwischen 2 Arrays
|
141
|
+
def isec(b)
|
142
|
+
raise ArgumentError, "#{b.inspect} is not an array" if !b.is_a?(Array)
|
143
|
+
(self- (self-b))
|
144
|
+
end
|
145
|
+
|
146
|
+
# like except for hash
|
147
|
+
def except(*args)
|
148
|
+
excluded = *args
|
149
|
+
return self - excluded
|
150
|
+
end
|
151
|
+
|
152
|
+
# break array into n arrays
|
153
|
+
def seperate(n = 8)
|
154
|
+
<<<<<<< HEAD
|
155
|
+
f = n
|
156
|
+
aks_size = self.size
|
157
|
+
rest = aks_size % f
|
158
|
+
|
159
|
+
stack = ((aks_size - rest) / f)
|
160
|
+
|
161
|
+
arrays = (1..f).to_a
|
162
|
+
|
163
|
+
arrays.map! {|i| self.first(stack*i).last(stack) }
|
164
|
+
=======
|
165
|
+
@f = n
|
166
|
+
aks_size = self.size
|
167
|
+
rest = aks_size % @f
|
168
|
+
|
169
|
+
@stack = ((aks_size - rest) / @f)
|
170
|
+
|
171
|
+
arrays = (1..@f).to_a
|
172
|
+
|
173
|
+
arrays.map! {|i| self.first(@stack*i).last(@stack) }
|
174
|
+
>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
|
175
|
+
arrays[-1] += self.last(rest) if rest != 0
|
176
|
+
#arrays.last.pop if (arrays.last.last.empty? || arrays.last.last.blank?)
|
177
|
+
return arrays
|
178
|
+
end
|
179
|
+
|
180
|
+
# [1,2,3,5,6,7].stack(2)
|
181
|
+
# will return [[1, 2], [3, 5], [6, 7]]
|
182
|
+
def stack(n = 4)
|
183
|
+
arr = []
|
184
|
+
i = (self.size.to_f/n).ceil
|
185
|
+
i.times do |x|
|
186
|
+
arr << self[x*n..(((x+1)*n)-1)]
|
187
|
+
end
|
188
|
+
return arr
|
189
|
+
end
|
190
|
+
|
191
|
+
|
192
|
+
# Prepare array for use with mysql IN operator
|
193
|
+
def to_sql
|
194
|
+
return "(NULL)" if self.empty?
|
195
|
+
if self.first.is_a?(Numeric)
|
196
|
+
return "(#{self.join(',')})"
|
197
|
+
else
|
198
|
+
return "(#{self.map{|i| "'#{i.to_s}'"}.join(',')})"
|
199
|
+
end
|
200
|
+
end
|
201
|
+
|
202
|
+
#== Untested / deprecated functions below, should be moved somewhere else!
|
203
|
+
# Ignore these functions, there are neither tested nor documented, use them for fun if you like but dont ask me ;-)
|
204
|
+
|
205
|
+
def fill_with_sth(sth, size)
|
206
|
+
ary_length = self.size
|
207
|
+
diff = size - ary_length
|
208
|
+
if diff > 0
|
209
|
+
pop = Array.new(diff){|i| sth}
|
210
|
+
new_ary = pop.push(self).flatten!
|
211
|
+
return new_ary
|
212
|
+
else
|
213
|
+
return self
|
214
|
+
end
|
215
|
+
end
|
216
|
+
|
217
|
+
|
218
|
+
# Generiert einen JSON-String aus einem Array mit Werten
|
219
|
+
def json_labels
|
220
|
+
json = "["
|
221
|
+
self.each_with_index {|l,i| json << '{"id": "%s", "text": "%s"}' % [i, l] ; json << "," unless i+1 == self.size}
|
222
|
+
json << "]"
|
223
|
+
end
|
224
|
+
|
225
|
+
def to_text(sep = "<br />")
|
226
|
+
if Rails.env == "development"
|
227
|
+
raise "#REMOVED - use .join() - (17.12.2013, 15:18, Florian Eck)"
|
228
|
+
else
|
229
|
+
self.join(sep)
|
230
|
+
end
|
231
|
+
<<<<<<< HEAD
|
232
|
+
end
|
233
|
+
|
234
|
+
|
235
|
+
def interpolate(filtered_value = nil, options = {})
|
236
|
+
begin
|
237
|
+
|
238
|
+
int_start_value = nil
|
239
|
+
int_end_value = nil
|
240
|
+
int_from = 0
|
241
|
+
int_to = 0
|
242
|
+
int_steps = 0
|
243
|
+
|
244
|
+
array_with_interpolation = []
|
245
|
+
|
246
|
+
self.each_with_index do |x,i|
|
247
|
+
if i > 0
|
248
|
+
if x != filtered_value
|
249
|
+
# Wenn der letze ein fehler war ist die strecke zuende
|
250
|
+
if self[i-1] == filtered_value
|
251
|
+
|
252
|
+
if i-1 == 0
|
253
|
+
# Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
|
254
|
+
#
|
255
|
+
m = (self[i+1]-x)
|
256
|
+
|
257
|
+
array_with_interpolation[0] = x-m
|
258
|
+
array_with_interpolation << x
|
259
|
+
|
260
|
+
else
|
261
|
+
int_end_value = x
|
262
|
+
int_to = i
|
263
|
+
|
264
|
+
# Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
|
265
|
+
m = (int_end_value-int_start_value).fdiv((int_to-int_from))
|
266
|
+
|
267
|
+
# Fülle fehlende werte mit werten (y = mx + b)
|
268
|
+
int_steps.times {|mi| array_with_interpolation << (int_start_value+((mi+1)*m)) }
|
269
|
+
array_with_interpolation << int_end_value
|
270
|
+
|
271
|
+
# Reset all values
|
272
|
+
int_start_value = int_end_value
|
273
|
+
int_end_value = nil
|
274
|
+
int_from = 0
|
275
|
+
int_to = 0
|
276
|
+
int_steps = 0
|
277
|
+
puts array_with_interpolation.inspect
|
278
|
+
end
|
279
|
+
else
|
280
|
+
int_start_value = x
|
281
|
+
array_with_interpolation << x
|
282
|
+
end
|
283
|
+
# Wenn letzer wert fehlerhaft
|
284
|
+
elsif i == self.size-1 && x == filtered_value
|
285
|
+
# Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
|
286
|
+
# Berechnung über gesamtes array
|
287
|
+
m = (array_with_interpolation.last-array_with_interpolation.first).fdiv(array_with_interpolation.size-1)
|
288
|
+
array_with_interpolation << (array_with_interpolation.last+m)
|
289
|
+
else
|
290
|
+
int_steps += 1
|
291
|
+
int_from = i-int_steps
|
292
|
+
end
|
293
|
+
|
294
|
+
else
|
295
|
+
int_start_value = x
|
296
|
+
array_with_interpolation << x
|
297
|
+
end
|
298
|
+
|
299
|
+
end
|
300
|
+
|
301
|
+
return array_with_interpolation
|
302
|
+
rescue
|
303
|
+
puts "WARNING: Interpolation not possible!".red
|
304
|
+
return self
|
305
|
+
end
|
306
|
+
|
307
|
+
end
|
308
|
+
=======
|
309
|
+
end
|
310
|
+
>>>>>>> ad58e345c5de2638e34e44d69bb19b0ebebcd41e
|
311
|
+
|
312
|
+
end
|
313
|
+
end
|
data/lib/nil_class.rb
CHANGED
data/lib/numbers.rb
CHANGED
@@ -2,32 +2,6 @@
|
|
2
2
|
# Numeric Extensions
|
3
3
|
module Numbers
|
4
4
|
|
5
|
-
# returns an array with all prime numbers up to limit
|
6
|
-
def self.prime_numbers(limit = 1_000_000, options = {:verbose => false})
|
7
|
-
i = 1; divisors = [2]; primzahlen = []
|
8
|
-
t = Time.now
|
9
|
-
while i <= limit do
|
10
|
-
p = true
|
11
|
-
divisors.each do |d|
|
12
|
-
if i%d == 0 && d != i
|
13
|
-
p = false
|
14
|
-
break
|
15
|
-
end
|
16
|
-
end
|
17
|
-
|
18
|
-
if p == true
|
19
|
-
puts i if options[:verbose] == true
|
20
|
-
primzahlen << i
|
21
|
-
end
|
22
|
-
|
23
|
-
i += 1
|
24
|
-
divisors << divisors.last+1
|
25
|
-
end
|
26
|
-
|
27
|
-
puts "Took #{(t-Time.now).abs.round(2)} sec." if options[:verbose] == true
|
28
|
-
return primzahlen
|
29
|
-
end
|
30
|
-
|
31
5
|
Numeric.class_eval do
|
32
6
|
|
33
7
|
# Convert Number to numeric german style with precision
|
@@ -51,7 +25,6 @@ module Numbers
|
|
51
25
|
|
52
26
|
# Convert Number to numeric german style without precision
|
53
27
|
def to_de(label=nil)
|
54
|
-
nr = self.round.to_i
|
55
28
|
result = ActionController::Base.helpers.number_with_precision(self, :precision => 0, :separator => ",", :delimiter => ".")
|
56
29
|
if !label.blank?
|
57
30
|
return [result, label].join(" ").html_safe
|
@@ -95,12 +68,12 @@ module Numbers
|
|
95
68
|
|
96
69
|
# tested
|
97
70
|
def min(ref)
|
98
|
-
[self, ref].min
|
71
|
+
[self.to_f, ref.to_f].min
|
99
72
|
end
|
100
73
|
|
101
74
|
# tested
|
102
75
|
def max(ref)
|
103
|
-
[self, ref].max
|
76
|
+
[self.to_f, ref.to_f].max
|
104
77
|
end
|
105
78
|
|
106
79
|
# Wert zwischen den Grenzen, ansonsten ober-oder unterkante
|
@@ -161,8 +134,33 @@ module Numbers
|
|
161
134
|
def days_to_months(options = {:s_days => "Tage", :s_months => "Monate", :s_sep => "und"})
|
162
135
|
x = [self/30, self%30]
|
163
136
|
"#{x[0]} #{options[:s_months]} #{options[:s_sep]} #{x[1]} #{options[:s_days]}"
|
164
|
-
end
|
165
|
-
|
137
|
+
end
|
138
|
+
|
139
|
+
|
140
|
+
# Split number in smallest prime factors
|
141
|
+
def prime_factors(options = {})
|
142
|
+
options[:nrs] ||= Math.sqrt(self).floor.prime_numbers
|
143
|
+
options[:nrs].each_with_index do |n,i|
|
144
|
+
if self%n == 0
|
145
|
+
return [n, (self/n).prime_factors(:nrs => options[:nrs])].flatten.except(1)
|
146
|
+
elsif i == options[:nrs].size-1
|
147
|
+
return [self]
|
148
|
+
end
|
149
|
+
end
|
150
|
+
end
|
151
|
+
|
152
|
+
# Create list with prime numbers up to 'self'
|
153
|
+
def prime_numbers
|
154
|
+
s = (0..self).to_a
|
155
|
+
s[0] = s[1] = nil
|
156
|
+
s.each do |p|
|
157
|
+
next unless p
|
158
|
+
break if p * p > self
|
159
|
+
(p*p).step(self, p) { |m| s[m] = nil }
|
160
|
+
end
|
161
|
+
s.compact
|
162
|
+
end
|
163
|
+
|
166
164
|
end
|
167
165
|
|
168
166
|
|