Specs

bindings?(formula :: t() | binary() | tuple(), binding :: keyword()) ::
  keyword()

Returns the binding this formula requires.

Examples

iex> "a > 5" |> Formulae.bindings?
~w|a|a

iex> ":math.sin(a / (3.14 * b)) > c" |> Formulae.bindings?
~w|a b c|a

iex> "a + b * 4 - :math.pow(c, 2) / d > 1.0 * e" |> Formulae.bindings?
~w|a b c d e|a

Specs

check(string :: binary(), bindings :: keyword()) :: boolean()

Revalidates the formula with bindings given. Returns true if the formula strictly evaluates to true, false otherwise. Compiles the formula before evaluation if needed.

Specs

combinations(list :: list(), count :: non_neg_integer()) :: [list()]

Generated clauses for n ∈ [1..42] to be used with dynamic number

Specs

compile(t() | binary(), options :: options()) :: t()

Compiles the formula into module.

Examples:

iex> f = Formulae.compile("rem(a, 5) - b == 0")
iex> f.formula
"rem(a, 5) - b == 0"
iex> f.variables
[:a, :b]
iex> f.module
:"Elixir.Formulae.rem(a, 5) - b == 0"
iex> f.module.eval(a: 12, b: 2)
true

iex> f = Formulae.compile("rem(a, 5) + b == a")
iex> f.variables
[:a, :b]
iex> f.eval.(a: 7, b: 5)
true
iex> f.eval.(a: 7, b: 0)
false

Specs

compiled?(binary() | t(), options :: options()) :: boolean()

Checks whether the formula was already compiled into module.

Typically one does not need to call this function, since this check would be nevertheless transparently performed before the evaluation.

Examples:

iex> Formulae.compiled?("foo > 42")
false
iex> Formulae.compile("foo > 42")
iex> Formulae.compiled?("foo > 42")
true

Specs

curry(input :: t() | binary(), binding :: keyword(), opts :: keyword()) :: t()

Curries the formula by substituting the known bindings into it.

Example

iex> Formulae.curry("(temp - foo * 4) > speed / 3.14", temp: 7, speed: 3.14).formula
"7 - foo * 4 > 3.14 / 3.14"

Specs

ensure_compiled(binary() | t(), options :: options()) ::
  {:module, module()}
  | {:error, :embedded | :badfile | :nofile | :on_load_failure | :unavailable}

Checks whether the formula was already compiled into module. Similar to compiled?/1, but returns what Code.ensure_compiled/1 returns.

Typically one does not need to call this function, since this check would be nevertheless transparently performed before the evaluation.

Examples:

iex> Formulae.ensure_compiled("bar > 42")
{:error, :nofile}
iex> Formulae.compile("bar > 42")
iex> Formulae.ensure_compiled("bar > 42")
{:module, :"Elixir.Formulae.bar > 42"}

Specs

eval(input :: binary() | t(), bindings :: keyword()) :: term() | {:error, any()}

Evaluates the formula returning the result back.

Examples:

iex> Formulae.eval("rem(a, 5) + rem(b, 4) == 0", a: 20, b: 20)
true
iex> Formulae.eval("rem(a, 5) == 0", a: 21)
false
iex> Formulae.eval("rem(a, 5) + rem(b, 4)", a: 21, b: 22)
3

Specs

eval!(input :: binary() | t(), bindings :: keyword()) :: term() | no_return()

Evaluates the formula returning the result back; throws in a case of unseccessful processing.

Examples:

iex> Formulae.eval!("rem(a, 5) == 0", a: 20)
true
iex> Formulae.eval!("rem(a, 5) == 0")
** (Formulae.RunnerError) Formula failed to run (compile): [:missing_arguments] wrong or incomplete eval call: [given_keys: [], expected_keys: [:a]].

Specs

evaluate(input :: binary() | tuple(), binding :: keyword(), opts :: keyword()) ::
  boolean() | no_return()

Evaluates normalized representation of formula.

Examples

iex> Formulae.eval("3 > 2")
true

iex> Formulae.eval("3 < 2")
false

iex> Formulae.eval("a < 2", a: 1)
true

iex> Formulae.eval("a > 2", a: 1)
false

iex> Formulae.eval("a < 2", [])
{:error, {:missing_arguments, [given_keys: [], expected_keys: [:a]]}}

iex> Formulae.eval!("a < 2", [])
** (Formulae.RunnerError) Formula failed to run (compile): [:missing_arguments] wrong or incomplete eval call: [given_keys: [], expected_keys: [:a]].

iex> Formulae.eval("a + 2 == 3", a: 1)
true

iex> Formulae.eval("a + 2 == 3", a: 2)
false

iex> Formulae.eval(~S|a == "3"|, a: "3")
true

iex> Formulae.eval(~S|a == "3"|, a: 3)
false

iex> Formulae.eval(~S|a == "3"|, a: "hello")
false

iex> Formulae.eval("a + 2 == 3", a: 2)
false

iex> Formulae.eval(~S|a == "3"|, a: "3")
true

iex> Formulae.eval("a_b_c_490000 > 2", a_b_c_490000: 3)
true

Returns a normalized representation for the formula given.

Specs

permutations(list :: list(), count :: non_neg_integer()) :: [list()]

Generated clauses for n ∈ [1..12] to be used with dynamic number

Specs

purge(t() | binary(), options()) ::
  :ok | {:error, :not_compiled} | {:error, :code_delete}

Purges and discards the module for the formula given (if exists.)

Produces the normalized representation of formula. If the rho is an instance of Integer or Float, it’s left intact, otherwise it’s moved to the left side with negation.

Examples

iex > Formulae.unit("3 > 2")
{"3 > 2", {:>, [], [3, 2]}}

iex > Formulae.unit("3 - a > 2")
{"3 - a > 2", {:>, [], [{:-, [line: 1], [3, {:a, [line: 1], nil}]}, 2]}}

iex > Formulae.unit("3 > A + 2")
{"3 > a + 2",
  {:>, [],
    [{:-, [context: Formulae, import: Kernel],
      [3, {:+, [line: 1], [{:a, [line: 1], nil}, 2]}]}, 0]}}

iex > Formulae.unit("3 >= a + 2")
{"3 >= a + 2",
  {:>=, [],
    [{:-, [context: Formulae, import: Kernel],
      [3, {:+, [line: 1], [{:a, [line: 1], nil}, 2]}]}, 0]}}

iex > Formulae.unit("3 a > A + 2")
** (Formulae.SyntaxError) Formula [3 a > A + 2] syntax is incorrect (parsing): syntax error before: “a”.

iex > Formulae.unit("a + 2 = 3")
{"a + 2 = 3", {:==, [], [{:+, [line: 1], [{:a, [line: 1], nil}, 2]}, 3]}}

iex > Formulae.unit(~S|A = "3"|)
{"a = \"3\"", {:==, [], [{:a, [line: 1], nil}, "3"]}}