Current section
Files
Jump to
Current section
Files
lib/MathematicalFunctions.ex
defmodule MathematicalFunc do
require Float
@pi 3.14159
@e 2.718281
@moduledoc"""
A module to perform mathematical functions
"""
@doc"""
Takes a list of elements and computes the sine function element wise .
##Examples
iex> MathematicalFunc.sin([1,2,34,4,5])
["0.84", "0.91", "0.53", "-0.76", "-0.96"]
"""
@spec sin([number]) :: [charlist]
def sin(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.sin(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the Hyperbolic sine function element wise .
## Examples
iex>MathematicalFunc.sinh([1,2,34,4,5])
["1.18", "3.63", "291730871263727.43", "27.29", "74.20"]
"""
@spec sinh([number]) :: [charlist]
def sinh(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.sinh(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the asin function element wise .
## Examples
iex> MathematicalFunc.asin([1, -1, 0, 0.65, -0.98])
["1.57", "-1.57", "0.00", "0.71", "-1.37"]
"""
@spec asin([number]) :: [charlist]
def asin(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.asin(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the asin function element wise .
## Examples
iex> MathematicalFunc.asinh([1,2,34,4,5])
["0.88", "1.44", "4.22", "2.10", "2.31"]
"""
@spec asinh([number]) :: [charlist]
def asinh(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.asinh(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the cos function element wise .
## Examples
iex> MathematicalFunc.cos([1,2,34,4,5])
["0.54", "-0.42", "-0.85", "-0.65", "0.28"]
"""
@spec cos([number]) :: [charlist]
def cos(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.cos(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the cosh function element wise .
## Examples
iex> MathematicalFunc.cosh([1,2,34,4,5])
["1.54", "3.76", "291730871263727.43", "27.31", "74.21"]
"""
@spec cosh([number]) :: [charlist]
def cosh(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.cosh(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the acos function element wise .
## Examples
iex> MathematicalFunc.acos([1, 0, -1, 0.8, -0.45])
["0.00", "1.57", "3.14", "0.64", "2.04"]
"""
@spec acos([number]) :: [charlist]
def acos(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.acos(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the acosh function element wise .
## Examples
iex> MathematicalFunc.acosh([1,2,34,4,5])
["0.00", "1.32", "4.22", "2.06", "2.29"]
"""
@spec acosh([number]) :: [charlist]
def acosh(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.acosh(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the tan function element wise .
## Examples
iex> MathematicalFunc.tan([1, 90, 0, 45])
["1.56", "-2.19", "0.00", "1.62"]
"""
@spec tan([number]) :: [charlist]
def tan(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.tan(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the tanh function element wise .
## Examples
iex> MathematicalFunc.tanh([1, -1])
["0.76", "-0.76"]
"""
@spec tanh([number]) :: [charlist]
def tanh(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.tanh(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the atan function element wise .
## Examples
iex> MathematicalFunc.atan([1,45])
["0.79", "1.55"]
"""
@spec atan([number]) :: [charlist]
def atan(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.atan(x), decimals: 2) end)
@doc"""
Takes a list of elements and computes the atanh function element wise .
## Examples
iex> MathematicalFunc.atanh([0.8, 0.9])
["1.10", "1.47"]
"""
@spec atanh([number]) :: [charlist]
def atanh(list), do: Enum.map(list, fn x -> :erlang.float_to_binary(:math.atanh(x), decimals: 2) end)
@doc"""
Takes the values of two sides of a right angled triangle and gives the hypotenuse .
## Examples
iex> MathematicalFunc.hypot(3, 4)
5.0
"""
@spec hypot(number, number) :: number
def hypot(s1, s2), do: :math.sqrt((s1 * s1) + (s2 * s2))
@doc"""
Convets the angle value in degrees to radians .
## Examples
iex> MathematicalFunc.deg2rad(180)
3.14159
"""
@spec deg2rad(number) :: number
def deg2rad(degree), do: degree * (@pi / 180)
@doc"""
Convets the angle value in radians to degrees.
## Examples
iex> MathematicalFunc.rad2deg(3.14159)
180
"""
@spec rad2deg(number) :: number
def rad2deg(radian), do: radian * (180 / @pi)
@doc"""
Round elements of the array to the nearest number.
## Examples
iex> MathematicalFunc.rint([3.89, 4.70, 5.62])
[4, 5, 6]
"""
@spec rint([number]) :: [number]
def rint(list), do: Enum.map(list, fn x -> round(x) end)
@doc"""
Return the floor of the input, element-wise.
## Examples
iex> MathematicalFunc.floor([3.89, 4.70, 5.62])
[3.0, 4.0, 5.0]
"""
@spec floor([number]) :: [number]
def floor(list), do: Enum.map(list, fn x -> Float.floor(x) end)
@doc"""
Return the ceiling of the input, element-wise.
## Examples
iex> MathematicalFunc.ceil([3.89, 4.70, 5.62])
[4.0, 5.0, 6.0]
"""
@spec ceil([number]) :: [number]
def ceil(list), do: Enum.map(list, fn x -> Float.ceil(x) end)
@doc"""
Return the truncated value of the input, element-wise.
## Examples
iex> MathematicalFunc.truncate([3.89, 4.70, 5.62])
[3, 4, 5]
"""
@spec truncate([number]) :: [number]
def truncate(list), do: Enum.map(list, fn x -> trunc(x) end)
defp exponent(base, ex), do: :math.pow(base, ex)
@doc"""
Calculate the exponential of all elements in the input array.
## Examples
iex> MathematicalFunc.exp([2,3,5])
[7.38, 20.08, 148.41]
"""
@spec exp([number]) :: [number]
def exp(list), do: Enum.map(list, fn x -> exponent(@e, x) end)
@doc"""
Calculate exp(x) - 1 for all elements in the array.
## Examples
iex> MathematicalFunc.exmp([2, 3, 5])
[6.38, 19.08, 147.41]
"""
@spec exmp([number]) :: [number]
def exmp(list), do: Enum.map(list, fn x -> exponent(@e, x) - 1 end)
@doc"""
Calculate :math.pow(2, x) for all x in the input array.
## Examples
iex> MathematicalFunc.exp2([4, 5, 6])
[16.0, 32.0, 64.0]
"""
@spec exp2([number]) :: [number]
def exp2(list), do: Enum.map(list, fn x -> exponent(2, x) end)
@doc"""
Natural logarithm, element-wise.
## Examples
iex> MathematicalFunc.log([3, 4, 5, 8])
[0.47, 0.60, 0.69, 0.90]
"""
@spec log([number]) :: [number]
def log(list), do: Enum.map(list, fn x -> :math.log(x) end)
@doc"""
Return the base 10 logarithm of the input array, element-wise.
## Examples
iex> MathematicalFunc.log10([10, 100, 1000])
[1.0, 2.0, 3.0]
"""
@spec log10([number]) :: [number]
def log10(list), do: Enum.map(list, fn x -> :math.log10(x) end)
@doc"""
Base-2 logarithm of x for all x in input array.
## Examples
iex> MathematicalFunc.log2([2,4, 8])
[1.0, 2.0, 3.0]
"""
@spec log2([number]) :: [number]
def log2(list), do: Enum.map(list, fn x -> :math.log2(x) end)
@doc"""
Logarithm of the sum of exponentiations of the inputs.
## Examples
iex> MathematicalFunc.logaddexp(5, 10)
10.006
"""
@spec logaddexp(number, number) :: number
def logaddexp(x1, x2), do: :math.log(exponent(@e, x1) + exponent(@e, x2))
@doc"""
Logarithm of the sum of exponentiations of the inputs in base-2.
## Examples
iex> MathematicalFunc.logaddexp2(2, 3)
2.48
"""
@spec logaddexp2(number, number) :: number
def logaddexp2(x1, x2), do: :math.log(exponent(2, x1) + exponent(2, x2))
@doc"""
Return the natural logarithm of one plus the input array, element-wise.
## Examples
iex> MathematicalFunc.log1p([4, 5, 7, 8])
[1.61, 1.79, 2.07, 2.19]
"""
@spec log1p([number]) :: [number]
def log1p(list), do: Enum.map(list, fn x -> :math.log(x + 1) end)
@doc"""
Add arguments element-wise.
## Examples
iex> MathematicalFunc.add([4, 6, 8190])
8200
"""
@spec add([number]) :: number
def add(list), do: Enum.sum(list)
@doc"""
Return the sinc function.
## Examples
iex> MathematicalFunc.sinc([4, 6, -4, 5])
[-0.09, -0.03, -0.09, 0.06]
"""
@spec sinc([number]) :: [number]
def sinc(list), do: Enum.map(list, fn x -> :math.sin(@e * x)/(@e * x) end)
end