defmodule Chi2fit.Utilities do
# Copyright 2015-2017 Pieter Rijken
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
@moduledoc """
Provides various utilities:
* Bootstrapping
* Creating Cumulative Distribution Functions / Histograms from sample data
* Autocorrelation coefficients
"""
alias Chi2fit.Distribution, as: D
alias Chi2fit.Distribution.Utilities, as: U
alias Chi2fit.Fit, as: F
alias Chi2fit.Math, as: M
alias Chi2fit.Matrix, as: Mx
alias Chi2fit.Statistics, as: S
@typedoc "Average and standard deviationm (error)"
@type avgsd :: {avg :: float, sd :: float}
@doc """
Reads data from a file specified by `filename` and returns a stream with the data parsed as floats.
It expects a single data point on a separate line and removes entries that:
* are not floats, and
* smaller than zero (0)
"""
@spec read_data(filename::String.t) :: Enumerable.t
def read_data(filename) do
filename
|> File.stream!([],:line)
|> Stream.flat_map(&String.split(&1,"\r",trim: true))
|> Stream.filter(&is_tuple(Float.parse(&1)))
|> Stream.map(&elem(Float.parse(&1),0))
|> Stream.filter(&(&1 >= 0.0))
end
@doc """
Unzips lists of 1-, 2-, 3-, 4-, 5-, 6-, 7-, and 8-tuples.
"""
@spec unzip(list::[tuple]) :: tuple
def unzip([]), do: {}
def unzip([{}|_]), do: {}
def unzip(list=[{_}|_]), do: {Enum.map(list,fn {x}->x end)}
def unzip(list=[{_,_}|_]), do: Enum.unzip(list)
def unzip(list=[{_,_,_}|_]) do
{
list |> Enum.map(&elem(&1,0)),
list |> Enum.map(&elem(&1,1)),
list |> Enum.map(&elem(&1,2))
}
end
def unzip(list=[{_,_,_,_}|_]) do
{
list |> Enum.map(&elem(&1,0)),
list |> Enum.map(&elem(&1,1)),
list |> Enum.map(&elem(&1,2)),
list |> Enum.map(&elem(&1,3))
}
end
def unzip(list=[{_,_,_,_,_}|_]) do
{
list |> Enum.map(&elem(&1,0)),
list |> Enum.map(&elem(&1,1)),
list |> Enum.map(&elem(&1,2)),
list |> Enum.map(&elem(&1,3)),
list |> Enum.map(&elem(&1,4))
}
end
def unzip(list=[{_,_,_,_,_,_}|_]) do
{
list |> Enum.map(&elem(&1,0)),
list |> Enum.map(&elem(&1,1)),
list |> Enum.map(&elem(&1,2)),
list |> Enum.map(&elem(&1,3)),
list |> Enum.map(&elem(&1,4)),
list |> Enum.map(&elem(&1,5))
}
end
def unzip(list=[{_,_,_,_,_,_,_}|_]) do
{
list |> Enum.map(&elem(&1,0)),
list |> Enum.map(&elem(&1,1)),
list |> Enum.map(&elem(&1,2)),
list |> Enum.map(&elem(&1,3)),
list |> Enum.map(&elem(&1,4)),
list |> Enum.map(&elem(&1,5)),
list |> Enum.map(&elem(&1,6))
}
end
def unzip(list=[_|_]) do
0..tuple_size(hd(list))-1
|> Enum.reduce({},fn i,tup -> Tuple.append(tup,list |> Enum.map(&elem(&1,i))) end)
end
##
## Local functions
##
@doc """
Outputs and formats the errors that result from a call to `Chi2fit.Fit.chi2/4`
Errors are tuples of length 2 and larger: `{[min1,max1], [min2,max2], ...}`.
"""
@spec puts_errors(device :: IO.device(), errors :: tuple()) :: none()
def puts_errors(device \\ :stdio, errors) do
errors
|> Tuple.to_list
|> Enum.with_index
|> Enum.each(fn
{[mn,mx],0} -> IO.puts device, "\t\t\tchi2:\t\t#{mn}\t-\t#{mx}"
{[mn,mx],_} -> IO.puts device, "\t\t\tparameter:\t#{mn}\t-\t#{mx}"
end)
end
@doc """
Displays results of the function `Chi2fit.Fit.chi2probe/4`
"""
@spec display(device :: IO.device(), F.chi2probe() | avgsd()) :: none()
def display(device \\ :stdio, results)
def display(device,{chi2, parameters, errors, _saved}) do
IO.puts device,"Initial guess:"
IO.puts device," chi2:\t\t#{chi2}"
IO.puts device," pars:\t\t#{inspect parameters}"
IO.puts device," ranges:\t\t#{inspect errors}\n"
end
def display(device,{avg, sd, direction}) when direction in [:-, :+] do
op = case direction do
:+ -> &Kernel.+/2
:- -> &Kernel.-/2
end
IO.puts device,"50% => #{:math.ceil(avg)} units"
IO.puts device,"84% => #{:math.ceil(op.(avg,sd))} units"
IO.puts device,"97.5% => #{:math.ceil(op.(avg,2*sd))} units"
IO.puts device,"99.85% => #{:math.ceil(op.(avg,3*sd))} units"
end
def display(device, {list, direction}) when is_list(list) and direction in [:-, :+] do
sorted = case direction do
:+ -> list |> Enum.sort
:- -> list |> Enum.sort |> Enum.reverse
end
max = length(sorted)
IO.puts device,"50% => #{Enum.at(sorted,round(0.5 * max))} units"
IO.puts device,"84% => #{Enum.at(sorted,round(0.84 * max))} units"
IO.puts device,"97.5% => #{Enum.at(sorted,round(0.975 * max))} units"
IO.puts device,"99.85% => #{Enum.at(sorted,round(0.9985 * max))} units"
end
@doc """
Pretty prints subsequences.
"""
@spec display_subsequences(device :: IO.device(), trends :: list(), intervals :: [NaiveDateTime.t]) :: none()
def display_subsequences(device \\ :stdio, trends, intervals) do
trends
|> Stream.transform(1, fn arg={_,_,data}, index -> { [{arg, Enum.at(intervals,index)}], index+length(data)} end)
|> Stream.each(fn
{{chimin, [rate], subdata},date} ->
IO.puts device, "Subsequence ending @#{Timex.format!(date,~S({Mshort}, {D} {YYYY}))}"
IO.puts device, "----------------------------------"
IO.puts device, " chi2@minimum: #{Float.round(chimin,1)}"
IO.puts device, " delivery rate: #{Float.round(rate,1)}"
IO.puts device, " subsequence: #{inspect(subdata, charlists: :as_lists)}"
IO.puts device, ""
end)
|> Stream.run()
end
@doc """
Displays results of the function `Chi2fit.Fit.chi2fit/4`
"""
@spec display(device :: IO.device(),hdata :: S.ecdf(),model :: U.model(),F.chi2fit(),options :: Keyword.t) :: none()
def display(device \\ :stdio,hdata,model,{chi2, cov, parameters, errors},options) do
param_errors = cov |> Mx.diagonal |> Enum.map(fn x->x|>abs|>:math.sqrt end)
IO.puts device,"Final:"
IO.puts device," chi2:\t\t#{chi2}"
IO.puts device," Degrees of freedom:\t#{length(hdata)-D.size(model)}"
IO.puts device," gradient:\t\t#{inspect M.jacobian(parameters,&F.chi2(hdata,fn x->D.cdf(model).(x,&1) end,fn _->0.0 end,options),options)}"
IO.puts device," parameters:\t\t#{inspect parameters}"
IO.puts device," errors:\t\t#{inspect param_errors}"
IO.puts device," ranges:"
puts_errors device,errors
end
@doc """
Walks a map structure while applying the function `fun`.
"""
@spec analyze(map :: %{}, fun :: (([number],Keyword.t) -> Keyword.t), options :: Keyword.t) :: Keyword.t
def analyze(map = %{}, fun, options) do
map |> Enum.reduce(%{}, fn {k,v},acc -> Map.put(acc,k,analyze(v,fun,options)) end)
end
def analyze(data, fun, options) when is_list(data) do
cond do
Keyword.keyword?(data) ->
Keyword.merge(data, fun.(data,Keyword.put(options,:bin,data[:bin])))
true ->
analyze([throughput: data, bin: options[:bin]], fun, options)
end
end
@doc """
Pretty-prints a nested array-like structure (list or tuple) as a table.
"""
@spec as_table(rows :: [any], header :: tuple()) :: list()
def as_table(rows, header) do
map = 1..tuple_size(header) |> Enum.map(&{&1,0}) |> Enum.into(%{})
table = [header|rows] |> _to_string()
map = Enum.reduce(table, map, fn row,acc ->
row
|> Enum.with_index(1)
|> Enum.reduce(acc, fn {str,i},acc2 -> Map.update!(acc2, i, fn v -> max(v,String.length(str)) end) end)
end)
table
|> Enum.with_index()
|> Enum.each(fn
{row, 0} ->
IO.puts row |> Enum.with_index(1) |> Enum.map(fn {str,i} -> String.pad_trailing(str, map[i]) end) |> Enum.join("|")
IO.puts row |> Enum.with_index(1) |> Enum.map(fn {_,i} -> String.duplicate("-",map[i]) end) |> Enum.join("|")
{row, _} ->
IO.puts row |> Enum.with_index(1) |> Enum.map(fn {str,i} -> String.pad_trailing(str, map[i]) end) |> Enum.join("|")
end)
rows
end
defp _to_string(list) when is_list(list), do: list |> Enum.map(&_to_string/1)
defp _to_string(tuple) when is_tuple(tuple), do: tuple |> Tuple.to_list |> _to_string()
defp _to_string(string) when is_binary(string), do: string
defp _to_string(float) when is_float(float), do: "#{float}"
defp _to_string(integer) when is_integer(integer), do: "#{integer}"
@doc ~S"""
## Examples
iex> subsequences []
[]
iex> subsequences [:a, :b]
[[:a], [:a, :b]]
iex> Stream.cycle([1,2,3]) |> subsequences |> Enum.take(4)
[[1], [1, 2], [1, 2, 3], [1, 2, 3, 1]]
"""
@spec subsequences(Enumerable.t) :: Enumerable.t
def subsequences(stream) when is_function(stream, 2) do
stream
|> Stream.transform([], fn x,acc -> {[Enum.reverse([x|acc])], [x|acc]} end)
end
def subsequences(list) do
{result, _} = list
|> Enum.reduce({[],[]}, fn x, {res,acc} -> {[Enum.reverse([x|acc])|res], [x|acc]} end)
Enum.reverse(result)
end
end
