def test_statsmodels_glm_cauchy_link_func():
estimator = utils.StatsmodelsSklearnLikeWrapper(
sm.GLM,
dict(init=dict(
family=sm.families.Binomial(
sm.families.links.cauchy())),
fit=dict(maxiter=1)))
estimator = estimator.fit([[1], [2]], [0.1, 0.2])
assembler = assemblers.StatsmodelsModelAssemblerSelector(estimator)
actual = assembler.assemble()
expected = ast.BinNumExpr(
ast.NumVal(0.5),
ast.BinNumExpr(
ast.AtanExpr(
ast.BinNumExpr(
ast.NumVal(0.0),
ast.BinNumExpr(
ast.FeatureRef(0),
ast.NumVal(-0.7279996905393095),
ast.BinNumOpType.MUL),
ast.BinNumOpType.ADD)),
ast.NumVal(3.141592653589793),
ast.BinNumOpType.DIV),
ast.BinNumOpType.ADD)
assert utils.cmp_exprs(actual, expected)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
Module Model
Function Score(ByRef inputVector() As Double) As Double
Score = Atan(2.0)
End Function
Function Xatan(ByVal x As Double) As Double
Dim z As Double
z = x * x
z = z * ((((-8.750608600031904122785e-01 * z _
- 1.615753718733365076637e+01) * z _
- 7.500855792314704667340e+01) * z _
- 1.228866684490136173410e+02) * z _
- 6.485021904942025371773e+01) _
/ (((((z + 2.485846490142306297962e+01) * z _
+ 1.650270098316988542046e+02) * z _
+ 4.328810604912902668951e+02) * z _
+ 4.853903996359136964868e+02) * z _
+ 1.945506571482613964425e+02)
Xatan = x * z + x
End Function
Function Satan(ByVal x As Double) As Double
Dim morebits as Double
Dim tan3pio8 as Double
morebits = 6.123233995736765886130e-17
tan3pio8 = 2.41421356237309504880
If x <= 0.66 Then
Satan = Xatan(x)
Exit Function
End If
If x > tan3pio8 Then
Satan = 1.57079632679489661923132169163 - Xatan(1.0 / x) + morebits
Exit Function
End If
Satan = 0.78539816339744830961566084581 + Xatan((x - 1) / (x + 1)) _
+ 3.061616997868382943065e-17
End Function
Function Atan(ByVal number As Double) As Double
' Implementation is taken from
' https://github.com/golang/go/blob/master/src/math/atan.go
If number = 0.0 Then
Atan = 0.0
Exit Function
End If
If number > 0.0 Then
Atan = Satan(number)
Exit Function
End If
Atan = -Satan(-number)
End Function
End Module
"""
interpreter = VisualBasicInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
let score (input : double list) =
atan (2.0)
"""
interpreter = FSharpInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
function score(input) {
return Math.atan(2.0);
}
"""
interpreter = JavascriptInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
score <- function(input) {
return(atan(2.0))
}
"""
interpreter = RInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
import math
def score(input):
return math.atan(2.0)
"""
interpreter = PythonInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
fn score(input: Vec<f64>) -> f64 {
f64::atan(2.0_f64)
}
"""
interpreter = RustInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
import 'dart:math';
double score(List<double> input) {
return atan(2.0);
}
"""
interpreter = DartInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
def score(input)
Math.atan(2.0)
end
"""
interpreter = RubyInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
function Score([double[]] $InputVector) {
return [math]::Atan(2.0)
}
"""
interpreter = PowershellInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
interpreter = GoInterpreter()
expected_code = """
import "math"
func score(input []float64) float64 {
return math.Atan(2.0)
}"""
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
<?php
function score(array $input) {
return atan(2.0);
}
"""
interpreter = PhpInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
interpreter = interpreters.CInterpreter()
expected_code = """
#include <math.h>
double score(double * input) {
return atan(2.0);
}"""
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
module Model where
score :: [Double] -> Double
score input =
atan (2.0)
"""
interpreter = HaskellInterpreter()
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
interpreter = JavaInterpreter()
expected_code = """
public class Model {
public static double score(double[] input) {
return Math.atan(2.0);
}
}"""
utils.assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
expected_code = """
using static System.Math;
namespace ML {
public static class Model {
public static double Score(double[] input) {
return Atan(2.0);
}
}
}
"""
interpreter = CSharpInterpreter()
assert_code_equal(interpreter.interpret(expr), expected_code)
def test_atan_fallback_expr():
expr = ast.AtanExpr(ast.NumVal(2.0))
interpreter = PythonInterpreter()
interpreter.atan_function_name = NotImplemented
expected_code = (
"""
def score(input):
var1 = 2.0
var2 = abs(var1)
if (var2) > (2.414213562373095):
var0 = (1.0) / (var2)
else:
if (var2) > (0.66):
var0 = ((var2) - (1.0)) / ((var2) + (1.0))
else:
var0 = var2
var3 = var0
var4 = (var3) * (var3)
if (var2) > (2.414213562373095):
var5 = -1.0
else:
var5 = 1.0
if (var2) <= (0.66):
var6 = 0.0
else:
if (var2) > (2.414213562373095):
var6 = 1.5707963267948968
else:
var6 = 0.7853981633974484
if (var1) < (0.0):
var7 = -1.0
else:
var7 = 1.0
return (((((var3) * ((var4) * ((((var4) * (((var4) * (((var4) * """
"""(((var4) * (-0.8750608600031904)) - (16.157537187333652))) - """
"""(75.00855792314705))) - (122.88666844901361))) - """
"""(64.85021904942025)) / ((194.5506571482614) + ((var4) * """
"""((485.3903996359137) + ((var4) * ((432.88106049129027) + """
"""((var4) * ((165.02700983169885) + ((var4) * """
"""((24.858464901423062) + (var4))))))))))))) + (var3)) * """
"""(var5)) + (var6)) * (var7)""")
assert_code_equal(interpreter.interpret(expr), expected_code)
assert ast.count_exprs(
ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.ADD),
exclude_list={ast.BinExpr, ast.NumVal}
) == 0
assert ast.count_exprs(
ast.BinNumExpr(ast.NumVal(1), ast.NumVal(2), ast.BinNumOpType.ADD),
exclude_list={ast.BinNumExpr}
) == 2
EXPR_WITH_ALL_EXPRS = ast.BinVectorNumExpr(
ast.BinVectorExpr(
ast.VectorVal([
ast.AbsExpr(ast.NumVal(-2)),
ast.AtanExpr(ast.NumVal(2)),
ast.ExpExpr(ast.NumVal(2)),
ast.LogExpr(ast.NumVal(2)),
ast.Log1pExpr(ast.NumVal(2)),
ast.SigmoidExpr(ast.NumVal(2)),
ast.SqrtExpr(ast.NumVal(2)),
ast.PowExpr(ast.NumVal(2), ast.NumVal(3)),
ast.TanhExpr(ast.NumVal(1)),
ast.BinNumExpr(
ast.NumVal(0),
ast.FeatureRef(0),
ast.BinNumOpType.ADD)
]),
ast.IdExpr(
ast.SoftmaxExpr([
ast.NumVal(1),
def _cauchy_inversed(self, ast_to_transform):
return utils.add(
ast.NumVal(0.5),
utils.div(ast.AtanExpr(ast_to_transform), ast.NumVal(math.pi)))
