module Apate

# File lib/apate/array_methods.rb, line 7
def self.add(element, value)
  self.element_wise_computing(:+, element, value)
end

# File lib/apate/basic_methods.rb, line 3
def self.average arr
  self.sum(arr).to_f / arr.length
end

# File lib/apate/multi_set_methods.rb, line 3
def self.covariance x, y
  xl = x.length
  yl = y.length

  return unless xl == yl

  xm = self.average x
  ym = self.average y

  self.scalar_product(self.subtract(x, xm), self.subtract(y, ym))/(xl.to_f - 1)
end

# File lib/apate/matrix_methods.rb, line 23
def self.determinant(a)
  am = Matrix.new(a)
  det = am.determinant

  det
end

# File lib/apate/array_methods.rb, line 15
def self.divide(element, value)
  self.element_wise_computing(:/, element, value.to_f)
end

# File lib/apate/matrix_methods.rb, line 17
def self.invert_matrix(a)
  am = Matrix.new(a)
  am.invert.data
end

# File lib/apate/matrix_methods.rb, line 10
def self.matrix_add(a, b)
  am = Matrix.new(a)
  bm = Matrix.new(b)

  (am+bm).data
end

# File lib/apate/matrix_methods.rb, line 3
def self.matrix_multiply(a, b)
  am = Matrix.new(a)
  bm = Matrix.new(b)

  (am*bm).data
end

# File lib/apate/basic_methods.rb, line 18
def self.median arr
  sorted_arr = arr.sort
  length = arr.length
  if length % 2 == 0
    self.average(sorted_arr[length/2-1..length/2])
  else
    sorted_arr[(length-1)/2]
  end
end

# File lib/apate/basic_methods.rb, line 29
def self.mode arr
  freq = arr.inject(Hash.new(0)) { |h,v| h[v] += 1; h }
  arr.max_by { |v| freq[v] }

end

# File lib/apate/array_methods.rb, line 11
def self.multiply(element, value)
  self.element_wise_computing(:*, element, value)
end

# File lib/apate/array_methods.rb, line 19
def self.pow(element, value)
  self.element_wise_computing(:**, element, value.to_f)
end

# File lib/apate/array_methods.rb, line 24
def self.scalar_product x, y
  return unless x.length == y.length
  value = 0

  x.each_with_index do |xi, i|
    value += xi*y[i]
  end

  value
end

# File lib/apate/array_methods.rb, line 3
def self.subtract(element, value)
  self.element_wise_computing(:-, element, value)
end

# File lib/apate/basic_methods.rb, line 7
def self.sum arr
  arr.inject { |sum, el| sum + el }
end

# File lib/apate/basic_methods.rb, line 11
def self.variance arr
  m = self.average arr

  arr = self.subtract(arr, m)
  self.scalar_product(arr, arr).to_f/(arr.length-1)
end

# File lib/apate/array_methods.rb, line 38
def self.element_wise_computing method, elements, value
  if elements.kind_of?(Array)
    elements.map do |e|
      self.element_wise_computing(method, e, value)
    end
  else
    elements.send(method, value)
  end
end