Module: Daru::Maths::Statistics::Vector

Included in:
Vector
Defined in:
lib/daru/maths/statistics/vector.rb

Instance Method Summary collapse

Instance Method Details

#acf(max_lags = nil) ⇒ Object

Calculates the autocorrelation coefficients of the series.

The first element is always 1, since that is the correlation of the series with itself.

Examples:

ts = Daru::Vector.new((1..100).map { rand })

ts.acf   # => array with first 21 autocorrelations
ts.acf 3 # => array with first 3 autocorrelations


650
651
652
653
654
655
656
657
658
659
660
661
662
663
 
# File 'lib/daru/maths/statistics/vector.rb', line 650

def acf(max_lags=nil)
  max_lags ||= (10 * Math.log10(size)).to_i

  (0..max_lags).map do |i|
    if i == 0
      1.0
    else
      m = mean
      # can't use Pearson coefficient since the mean for the lagged series should
      # be the same as the regular series
      ((self - m) * (lag(i) - m)).sum / variance_sample / (size - 1)
    end
  end
end

#acvf(demean = true, unbiased = true) ⇒ Object

Provides autocovariance.

Options

  • :demean = true; optional. Supply false if series is not to be demeaned

  • :unbiased = true; optional. true/false for unbiased/biased form of autocovariance

Returns

Autocovariance value



675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
 
# File 'lib/daru/maths/statistics/vector.rb', line 675

def acvf(demean=true, unbiased=true)
  opts = {
    demean: true,
    unbaised: true
  }.merge(opts)

  demean   = opts[:demean]
  unbiased = opts[:unbiased]
  demeaned_series = demean ? self - mean : self

  n = (10 * Math.log10(size)).to_i + 1
  m = mean
  d = if unbiased
        Array.new(size, size)
      else
        (1..size).to_a.reverse[0..n]
      end

  0.upto(n - 1).map do |i|
    (demeaned_series * (lag(i) - m)).sum / d[i]
  end
end

#average_deviation_population(m = nil) ⇒ Object Also known as: adp 



238
239
240
241
242
243
244
 
# File 'lib/daru/maths/statistics/vector.rb', line 238

def average_deviation_population m=nil
  type == :numeric or raise TypeError, 'Vector must be numeric'
  m ||= mean
  (@data.inject(0) { |memo, val|
    @missing_values.key?(val) ? memo : (val - m).abs + memo
  }).quo(n_valid)
end

#box_cox_transformation(lambda) ⇒ Object

:nodoc:



321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
 
# File 'lib/daru/maths/statistics/vector.rb', line 321

def box_cox_transformation lambda # :nodoc:
  raise 'Should be a numeric' unless @type == :numeric

  recode do |x|
    if !x.nil?
      if lambda == 0
        Math.log(x)
      else
        (x ** lambda - 1).quo(lambda)
      end
    else
      nil
    end
  end
end

#center ⇒ Object

Center data by subtracting the mean from each non-nil value.



303
304
305
 
# File 'lib/daru/maths/statistics/vector.rb', line 303

def center
  self - mean
end

#coefficient_of_variation ⇒ Object Also known as: cov 



115
116
117
 
# File 'lib/daru/maths/statistics/vector.rb', line 115

def coefficient_of_variation
  standard_deviation_sample / mean
end

#count(value = false) ⇒ Object

Retrieves number of cases which comply condition. If block given, retrieves number of instances where block returns true. If other values given, retrieves the frequency for this value. If no value given, counts the number of non-nil elements in the Vector.



123
124
125
126
127
128
129
130
131
132
 
# File 'lib/daru/maths/statistics/vector.rb', line 123

def count value=false
  if block_given?
    @data.select { |val| yield(val) }.count
  elsif value
    val = frequencies[value]
    val.nil? ? 0 : val
  else
    size - @missing_positions.size
  end
end

#covariance_population(other) ⇒ Object

Population covariance with denominator (N)



181
182
183
184
185
186
187
188
189
190
 
# File 'lib/daru/maths/statistics/vector.rb', line 181

def covariance_population other
  @size == other.size or raise ArgumentError, 'size of both the vectors must be equal'
  mean_x = mean
  mean_y = other.mean
  sum = 0
  (0...size).each do |i|
    sum += ((@missing_values.key?(@data[i]) || other.missing_values.include?(other[i])) ? 0 : (@data[i] - mean_x) * (other.data[i] - mean_y))
  end
  sum / n_valid
end

#covariance_sample(other) ⇒ Object Also known as: covariance

Sample covariance with denominator (N-1)



169
170
171
172
173
174
175
176
177
178
 
# File 'lib/daru/maths/statistics/vector.rb', line 169

def covariance_sample other
  @size == other.size or raise ArgumentError, 'size of both the vectors must be equal'
  mean_x = mean
  mean_y = other.mean
  sum = 0
  (0...size).each do |i|
    sum += ((@missing_values.key?(@data[i]) || other.missing_values.include?(other[i])) ? 0 : (@data[i] - mean_x) * (other.data[i] - mean_y))
  end
  sum / (n_valid - 1)
end

#cumsum ⇒ Object

Calculate cumulative sum of Vector



699
700
701
702
703
704
705
706
707
708
709
710
711
712
 
# File 'lib/daru/maths/statistics/vector.rb', line 699

def cumsum
  result = []
  acc = 0
  @data.each do |d|
    if @missing_values.key?(d)
      result << nil
    else
      acc += d
      result << acc
    end
  end

  Daru::Vector.new(result, index: @index)
end

#describe(methods = nil) ⇒ Object

Create a summary of count, mean, standard deviation, min and max of the vector in one shot.

Arguments

methods - An array with aggregation methods specified as symbols to be applied to vectors. Default is [:count, :mean, :std, :max, :min]. Methods will be applied in the specified order.



44
45
46
47
48
 
# File 'lib/daru/maths/statistics/vector.rb', line 44

def describe methods=nil
  methods ||= [:count, :mean, :std, :min, :max]
  description = methods.map { |m| send(m) }
  Daru::Vector.new(description, index: methods, name: :statistics)
end

#dichotomize(low = nil) ⇒ Object

Dichotomize the vector with 0 and 1, based on lowest value. If parameter is defined, this value and lower will be 0 and higher, 1.



288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'lib/daru/maths/statistics/vector.rb', line 288

def dichotomize(low=nil)
  low ||= factors.min

  recode do |x|
    if x.nil?
      nil
    elsif x > low
      1
    else
      0
    end
  end
end

#diff(max_lags = 1) ⇒ Daru::Vector

Performs the difference of the series. Note: The first difference of series is X(t) - X(t-1) But, second difference of series is NOT X(t) - X(t-2) It is the first difference of the first difference

> (X(t) - X(t-1)) - (X(t-1) - X(t-2))

Arguments

  • max_lags: integer, (default: 1), number of differences reqd.

Examples:

Using #diff


ts = Daru::Vector.new((1..10).map { rand })
         # => [0.69, 0.23, 0.44, 0.71, ...]

ts.diff   # => [nil, -0.46, 0.21, 0.27, ...]

Returns:



452
453
454
455
456
457
458
459
460
 
# File 'lib/daru/maths/statistics/vector.rb', line 452

def diff(max_lags=1)
  ts = self
  difference = []
  max_lags.times do
    difference = ts - ts.lag
    ts = difference
  end
  difference
end

#ema(n = 10, wilder = false) ⇒ Daru::Vector

Exponential Moving Average. Calculates an exponential moving average of the series using a specified parameter. If wilder is false (the default) then the EMA uses a smoothing value of 2 / (n + 1), if it is true then it uses the Welles Wilder smoother of 1 / n.

Warning for EMA usage: EMAs are unstable for small series, as they use a lot more than n observations to calculate. The series is stable if the size of the series is >= 3.45 * (n + 1)

Examples:

Using ema


ts = Daru::Vector.new((1..100).map { rand })
         # => [0.577..., 0.123..., 0.173..., 0.233..., ...]

# first 9 observations are nil
ts.ema   # => [ ... nil, 0.455... , 0.395..., 0.323..., ... ]

Parameters:

  • n (Integer) (defaults to: 10) —

    (10) Loopback length.

  • wilder (TrueClass, FalseClass) (defaults to: false) —

    (false) If true, 1/n value is used for smoothing; if false, uses 2/(n+1) value

Returns:



536
537
538
539
540
541
542
543
544
545
546
547
548
549
 
# File 'lib/daru/maths/statistics/vector.rb', line 536

def ema(n=10, wilder=false)
  smoother = wilder ? 1.0 / n : 2.0 / (n + 1)
  # need to start everything from the first non-nil observation
  start = @data.index { |i| !i.nil? }
  # first n - 1 observations are nil
  base = [nil] * (start + n - 1)
  # nth observation is just a moving average
  base << @data[start...(start + n)].inject(0.0) { |s, a| a.nil? ? s : s + a } / n
  (start + n).upto size - 1 do |i|
    base << self[i] * smoother + (1 - smoother) * base.last
  end

  Daru::Vector.new(base, index: @index, name: @name)
end

#emsd(n = 10, wilder = false) ⇒ Daru::Vector

Exponential Moving Standard Deviation. Calculates an exponential moving standard deviation of the series using a specified parameter. If wilder is false (the default) then the EMSD uses a smoothing value of 2 / (n + 1), if it is true then it uses the Welles Wilder smoother of 1 / n.

Examples:

Using emsd


ts = Daru::Vector.new((1..100).map { rand })
         # => [0.400..., 0.727..., 0.862..., 0.013..., ...]

# first 9 observations are nil
ts.emsd   # => [ ... nil, 0.285... , 0.258..., 0.243..., ...]

Parameters:

  • n (Integer) (defaults to: 10) —

    (10) Loopback length.

  • wilder (TrueClass, FalseClass) (defaults to: false) —

    (false) If true, 1/n value is used for smoothing; if false, uses 2/(n+1) value

Returns:



607
608
609
610
611
612
613
614
 
# File 'lib/daru/maths/statistics/vector.rb', line 607

def emsd(n=10, wilder=false)
  result = []
  emv_return = emv(n, wilder)
  emv_return.each do |d|
    result << (d.nil? ? nil : Math.sqrt(d))
  end
  Daru::Vector.new(result, index: @index, name: @name)
end

#emv(n = 10, wilder = false) ⇒ Daru::Vector

Exponential Moving Variance. Calculates an exponential moving variance of the series using a specified parameter. If wilder is false (the default) then the EMV uses a smoothing value of 2 / (n + 1), if it is true then it uses the Welles Wilder smoother of 1 / n.

Examples:

Using emv


ts = Daru::Vector.new((1..100).map { rand })
         # => [0.047..., 0.23..., 0.836..., 0.845..., ...]

# first 9 observations are nil
ts.emv   # => [ ... nil, 0.073... , 0.082..., 0.080..., ...]

Parameters:

  • n (Integer) (defaults to: 10) —

    (10) Loopback length.

  • wilder (TrueClass, FalseClass) (defaults to: false) —

    (false) If true, 1/n value is used for smoothing; if false, uses 2/(n+1) value

Returns:



570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
 
# File 'lib/daru/maths/statistics/vector.rb', line 570

def emv(n=10, wilder=false)
  smoother = wilder ? 1.0 / n : 2.0 / (n + 1)
  # need to start everything from the first non-nil observation
  start = @data.index { |i| !i.nil? }
  # first n - 1 observations are nil
  var_base = [nil] * (start + n - 1)
  mean_base = [nil] * (start + n - 1)
  mean_base << @data[start...(start + n)].inject(0.0) { |s, a| a.nil? ? s : s + a } / n
  # nth observation is just a moving variance_population
  var_base << @data[start...(start + n)].inject(0.0) { |s,x| x.nil? ? s : s + (x - mean_base.last)**2 } / n
  (start + n).upto size - 1 do |i|
    last = mean_base.last
    mean_base << self[i] * smoother + (1 - smoother) * last
    var_base << (1 - smoother) * var_base.last + smoother * (self[i] - last) * (self[i] - mean_base.last)
  end
  Daru::Vector.new(var_base, index: @index, name: @name)
end

#factors ⇒ Object

Retrieve unique values of non-nil data



66
67
68
 
# File 'lib/daru/maths/statistics/vector.rb', line 66

def factors
  only_valid.uniq.reset_index!
end

#freqs ⇒ Object 



96
97
98
 
# File 'lib/daru/maths/statistics/vector.rb', line 96

def freqs
  Daru::Vector.new(frequencies)
end

#frequencies ⇒ Object 



90
91
92
93
94
 
# File 'lib/daru/maths/statistics/vector.rb', line 90

def frequencies
  @data.each_with_object(Hash.new(0)) do |element, hash|
    hash[element] += 1 unless element.nil?
  end
end

#kurtosis(m = nil) ⇒ Object 



228
229
230
231
232
233
234
235
236
 
# File 'lib/daru/maths/statistics/vector.rb', line 228

def kurtosis m=nil
  if @data.respond_to? :kurtosis
    @data.kurtosis
  else
    m ||= mean
    fo  = @data.inject(0) { |a, x| a + ((x - m) ** 4) }
    fo.quo((@size - @missing_positions.size) * standard_deviation_sample(m) ** 4) - 3
  end
end

#macd(fast = 12, slow = 26, signal = 9) ⇒ Object

Moving Average Convergence-Divergence. Calculates the MACD (moving average convergence-divergence) of the time series - this is a comparison of a fast EMA with a slow EMA.

Arguments

  • fast: integer, (default = 12) - fast component of MACD

  • slow: integer, (default = 26) - slow component of MACD

  • signal: integer, (default = 9) - signal component of MACD

Usage

ts = Daru::Vector.new((1..100).map { rand })
         # => [0.69, 0.23, 0.44, 0.71, ...]
ts.macd(13)

Returns

Array of two Daru::Vectors - comparison of fast EMA with slow and EMA with signal value



635
636
637
638
 
# File 'lib/daru/maths/statistics/vector.rb', line 635

def macd(fast=12, slow=26, signal=9)
  series = ema(fast) - ema(slow)
  [series, series.ema(signal)]
end

#max(return_type = :stored_type) ⇒ Object

Maximum element of the vector.

Parameters:

  • return_type (Symbol) (defaults to: :stored_type) —

    Data type of the returned value. Defaults to returning only the maximum number but passing :vector will return a Daru::Vector with the index of the corresponding maximum value.



75
76
77
78
79
80
81
82
 
# File 'lib/daru/maths/statistics/vector.rb', line 75

def max return_type=:stored_type
  max_value = @data.max
  if return_type == :vector
    Daru::Vector.new({index_of(max_value) => max_value}, name: @name, dtype: @dtype)
  else
    max_value
  end
end

#max_index ⇒ Daru::Vector

Return a Vector with the max element and its index.

Returns:



86
87
88
 
# File 'lib/daru/maths/statistics/vector.rb', line 86

def max_index
  max :vector
end

#mean ⇒ Object 



8
9
10
 
# File 'lib/daru/maths/statistics/vector.rb', line 8

def mean
  @data.mean
end

#median ⇒ Object 



28
29
30
 
# File 'lib/daru/maths/statistics/vector.rb', line 28

def median
  @data.respond_to?(:median) ? @data.median : percentile(50)
end

#median_absolute_deviation ⇒ Object Also known as: mad 



50
51
52
53
 
# File 'lib/daru/maths/statistics/vector.rb', line 50

def median_absolute_deviation
  m = median
  recode { |val| (val - m).abs }.median
end

#min ⇒ Object 



20
21
22
 
# File 'lib/daru/maths/statistics/vector.rb', line 20

def min
  @data.min
end

#mode ⇒ Object 



32
33
34
 
# File 'lib/daru/maths/statistics/vector.rb', line 32

def mode
  frequencies.max { |a,b| a[1]<=>b[1] }.first
end

#percent_change(periods = 1) ⇒ Object

The percent_change method computes the percent change over the given number of periods.

Examples:


vector = Daru::Vector.new([4,6,6,8,10],index: ['a','f','t','i','k'])
vector.percent_change
#=>
#   <Daru::Vector:28713060 @name = nil @size: 5 >
#              nil
#   a
#   f	   0.5
#   t	   0.0
#   i	   0.3333333333333333
#   k          0.25

Parameters:

  • periods (Integer) (defaults to: 1) —

    (1) number of nils to insert at the beginning.



417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
 
# File 'lib/daru/maths/statistics/vector.rb', line 417

def percent_change periods=1
  type == :numeric or raise TypeError, 'Vector must be numeric'
  value = only_valid
  arr = []
  i = 1
  ind = @data.find_index { |x| !x.nil? }
  (periods...size).each do |j|
    if j==ind || @missing_values.key?(@data[j])
      arr[j] = nil
    else
      arr[j] = (value.data[i] - value.data[i - 1]) / value.data[i - 1].to_f
      i+=1
    end
  end
  Daru::Vector.new(arr, index: @index, name: @name)
end

#percentile(q, strategy = :midpoint) ⇒ Object Also known as: percentil

Returns the value of the percentile q

Accepts an optional second argument specifying the strategy to interpolate when the requested percentile lies between two data points a and b Valid strategies are:

  • :midpoint (Default): (a + b) / 2

  • :linear : a + (b - a) * d where d is the decimal part of the index between a and b.

References

This is the NIST recommended method (en.wikipedia.org/wiki/Percentile#NIST_method)



256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'lib/daru/maths/statistics/vector.rb', line 256

def percentile(q, strategy=:midpoint)
  sorted = only_valid(:array).sort

  case strategy
  when :midpoint
    v = (n_valid * q).quo(100)
    if v.to_i!=v
      sorted[v.to_i]
    else
      (sorted[(v-0.5).to_i].to_f + sorted[(v+0.5).to_i]).quo(2)
    end
  when :linear
    index = (q / 100.0) * (n_valid + 1)

    k = index.truncate
    d = index % 1

    if k == 0
      sorted[0]
    elsif k >= sorted.size
      sorted[-1]
    else
      sorted[k - 1] + d * (sorted[k] - sorted[k - 1])
    end
  else
    raise NotImplementedError, "Unknown strategy #{strategy}"
  end
end

#product ⇒ Object 



16
17
18
 
# File 'lib/daru/maths/statistics/vector.rb', line 16

def product
  @data.product
end

#proportion(value = 1) ⇒ Object 



144
145
146
 
# File 'lib/daru/maths/statistics/vector.rb', line 144

def proportion value=1
  frequencies[value].quo(n_valid).to_f
end

#proportions ⇒ Object 



100
101
102
103
 
# File 'lib/daru/maths/statistics/vector.rb', line 100

def proportions
  len = n_valid
  frequencies.each_with_object({}) { |arr, hash| hash[arr[0]] = arr[1] / len }
end

#range ⇒ Object 



24
25
26
 
# File 'lib/daru/maths/statistics/vector.rb', line 24

def range
  max - min
end

#ranked ⇒ Object 



105
106
107
108
109
110
111
112
113
 
# File 'lib/daru/maths/statistics/vector.rb', line 105

def ranked
  sum = 0
  r = frequencies.sort.each_with_object({}) do |val, memo|
    memo[val[0]] = ((sum + 1) + (sum + val[1])).quo(2)
    sum += val[1]
  end

  recode { |e| r[e] }
end

#rolling(function, n = 10) ⇒ Daru::Vector

Calculate the rolling function for a loopback value.

Examples:

Using #rolling

ts = Daru::Vector.new((1..100).map { rand })
         # => [0.69, 0.23, 0.44, 0.71, ...]
# first 9 observations are nil
ts.rolling(:mean)    # => [ ... nil, 0.484... , 0.445... , 0.513 ... , ... ]

Parameters:

  • function (Symbol) —

    The rolling function to be applied. Can be any function applicatble to Daru::Vector (:mean, :median, :count, :min, :max, etc.)

  • n (Integer) (defaults to: 10) —

    (10) A non-negative value which serves as the loopback length.

Returns:



474
475
476
477
478
479
480
481
 
# File 'lib/daru/maths/statistics/vector.rb', line 474

def rolling function, n=10
  Daru::Vector.new(
    [nil] * (n - 1) +
    (0..(size - n)).map do |i|
      Daru::Vector.new(@data[i...(i + n)]).send(function)
    end, index: @index
  )
end

#rolling_count ⇒ Object

Calculate rolling non-missing count

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#rolling_max ⇒ Object

Calculate rolling max value

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#rolling_mean ⇒ Object

Calculate rolling average

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#rolling_median ⇒ Object

Calculate rolling median

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#rolling_min ⇒ Object

Calculate rolling min value

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#rolling_std ⇒ Object

Calculate rolling standard deviation

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#rolling_sum ⇒ Object

Calculate rolling sum

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#rolling_variance ⇒ Object

Calculate rolling variance

Parameters:

  • n (Integer) —

    (10) Loopback length



507
508
509
510
511
 
# File 'lib/daru/maths/statistics/vector.rb', line 507

[:count, :mean, :median, :max, :min, :sum, :std, :variance].each do |meth|
  define_method("rolling_#{meth}".to_sym) do |n=10|
    rolling(meth, n)
  end
end

#sample_with_replacement(sample = 1) ⇒ Object

Returns an random sample of size n, with replacement, only with non-nil data.

In all the trails, every item have the same probability of been selected.



366
367
368
369
370
371
372
373
374
 
# File 'lib/daru/maths/statistics/vector.rb', line 366

def sample_with_replacement(sample=1)
  if @data.respond_to? :sample_with_replacement
    @data.sample_with_replacement sample
  else
    valid = missing_positions.empty? ? self : only_valid
    vds = valid.size
    (0...sample).collect { valid[rand(vds)] }
  end
end

#sample_without_replacement(sample = 1) ⇒ Object

Returns an random sample of size n, without replacement, only with valid data.

Every element could only be selected once.

A sample of the same size of the vector is the vector itself.



382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/daru/maths/statistics/vector.rb', line 382

def sample_without_replacement(sample=1)
  if @data.respond_to? :sample_without_replacement
    @data.sample_without_replacement sample
  else
    valid = missing_positions.empty? ? self : only_valid
    raise ArgumentError, "Sample size couldn't be greater than n" if
      sample > valid.size
    out  = []
    size = valid.size
    while out.size < sample
      value = rand(size)
      out.push(value) unless out.include?(value)
    end

    out.collect { |i| valid[i] }
  end
end

#skew(m = nil) ⇒ Object

Calculate skewness using (sigma(xi - mean)^3)/((N)*std_dev_sample^3)



218
219
220
221
222
223
224
225
226
 
# File 'lib/daru/maths/statistics/vector.rb', line 218

def skew m=nil
  if @data.respond_to? :skew
    @data.skew
  else
    m ||= mean
    th  = @data.inject(0) { |memo, val| memo + ((val - m)**3) }
    th.quo((@size - @missing_positions.size) * (standard_deviation_sample(m)**3))
  end
end

#standard_deviation_population(m = nil) ⇒ Object Also known as: sdp 



199
200
201
202
203
204
205
206
 
# File 'lib/daru/maths/statistics/vector.rb', line 199

def standard_deviation_population m=nil
  m ||= mean
  if @data.respond_to? :standard_deviation_population
    @data.standard_deviation_population(m)
  else
    Math.sqrt(variance_population(m))
  end
end

#standard_deviation_sample(m = nil) ⇒ Object Also known as: sds, sd 



208
209
210
211
212
213
214
215
 
# File 'lib/daru/maths/statistics/vector.rb', line 208

def standard_deviation_sample m=nil
  m ||= mean
  if @data.respond_to? :standard_deviation_sample
    @data.standard_deviation_sample m
  else
    Math.sqrt(variance_sample(m))
  end
end

#standard_error ⇒ Object Also known as: se 



57
58
59
 
# File 'lib/daru/maths/statistics/vector.rb', line 57

def standard_error
  standard_deviation_sample/Math.sqrt(n_valid)
end

#standardize(use_population = false) ⇒ Object

Standardize data.

Arguments

  • use_population - Pass as true if you want to use population

standard deviation instead of sample standard deviation.



313
314
315
316
317
318
319
 
# File 'lib/daru/maths/statistics/vector.rb', line 313

def standardize use_population=false
  m ||= mean
  sd = use_population ? sdp : sds
  return Daru::Vector.new([nil]*@size) if m.nil? || sd == 0.0

  vector_standardized_compute m, sd
end

#sum ⇒ Object 



12
13
14
 
# File 'lib/daru/maths/statistics/vector.rb', line 12

def sum
  @data.sum
end

#sum_of_squared_deviation ⇒ Object 



61
62
63
 
# File 'lib/daru/maths/statistics/vector.rb', line 61

def sum_of_squared_deviation
  (@data.inject(0) { |a,x| x.square + a } - sum.square.quo(n_valid).to_f).to_f
end

#sum_of_squares(m = nil) ⇒ Object Also known as: ss 



192
193
194
195
196
197
 
# File 'lib/daru/maths/statistics/vector.rb', line 192

def sum_of_squares(m=nil)
  m ||= mean
  @data.inject(0) { |memo, val|
    @missing_values.key?(val) ? memo : (memo + (val - m)**2)
  }
end

#value_counts ⇒ Object

Count number of occurrences of each value in the Vector



135
136
137
138
139
140
141
142
 
# File 'lib/daru/maths/statistics/vector.rb', line 135

def value_counts
  values = {}
  @data.each do |d|
    values[d] ? values[d] += 1 : values[d] = 1
  end

  Daru::Vector.new(values)
end

#variance_population(m = nil) ⇒ Object

Population variance with denominator (N)



159
160
161
162
163
164
165
166
 
# File 'lib/daru/maths/statistics/vector.rb', line 159

def variance_population m=nil
  m ||= mean
  if @data.respond_to? :variance_population
    @data.variance_population m
  else
    sum_of_squares(m).quo(n_valid).to_f
  end
end

#variance_sample(m = nil) ⇒ Object Also known as: variance

Sample variance with denominator (N-1)



149
150
151
152
153
154
155
156
 
# File 'lib/daru/maths/statistics/vector.rb', line 149

def variance_sample m=nil
  m ||= mean
  if @data.respond_to? :variance_sample
    @data.variance_sample m
  else
    sum_of_squares(m).quo(n_valid - 1)
  end
end

#vector_centered_compute(m) ⇒ Object 



352
353
354
355
356
357
358
359
 
# File 'lib/daru/maths/statistics/vector.rb', line 352

def vector_centered_compute(m)
  if @data.respond_to? :vector_centered_compute
    @data.vector_centered_compute(m)
  else
    Daru::Vector.new @data.collect { |x| x.nil? ? nil : x.to_f-m },
      index: index, name: name, dtype: dtype
  end
end

#vector_percentile ⇒ Object

Replace each non-nil value in the vector with its percentile.



338
339
340
341
 
# File 'lib/daru/maths/statistics/vector.rb', line 338

def vector_percentile
  c = size - missing_positions.size
  ranked.recode! { |i| i.nil? ? nil : (i.quo(c)*100).to_f }
end

#vector_standardized_compute(m, sd) ⇒ Object 



343
344
345
346
347
348
349
350
 
# File 'lib/daru/maths/statistics/vector.rb', line 343

def vector_standardized_compute(m,sd)
  if @data.respond_to? :vector_standardized_compute
    @data.vector_standardized_compute(m,sd)
  else
    Daru::Vector.new @data.collect { |x| x.nil? ? nil : (x.to_f - m).quo(sd) },
      index: index, name: name, dtype: dtype
  end
end