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)))