From 6dcfa64cb2dcf82e467be61a4cf3b20ab3296839 Mon Sep 17 00:00:00 2001 From: Felipe Pena Date: Thu, 2 Jan 2025 16:05:05 -0300 Subject: [PATCH] fix --- vlib/math/stats/stats_test.v | 30 ++++++++++++------------- vlib/v/checker/assign.v | 5 +++++ vlib/v/gen/c/assign.v | 8 +++++++ vlib/v/type_resolver/generic_resolver.v | 2 +- vlib/v/type_resolver/type_resolver.v | 19 ++++++++++++++++ 5 files changed, 48 insertions(+), 16 deletions(-) diff --git a/vlib/math/stats/stats_test.v b/vlib/math/stats/stats_test.v index 3f59d7fb55684d..4610baba66acec 100644 --- a/vlib/math/stats/stats_test.v +++ b/vlib/math/stats/stats_test.v @@ -400,15 +400,15 @@ fn test_covariance() { mut data0 := [10.0, 4.45, 5.9, 2.7] mut data1 := [5.0, 14.45, -15.9, 22.7] mut o := stats.covariance(data0, data1) - assert math.alike(o, -17.37078207731247) + assert math.alike(o, -17.37078125) data0 = [-3.0, 67.31, 4.4, 1.89] data1 = [5.0, 77.31, 44.4, 11.89] o = stats.covariance(data0, data1) - assert math.alike(o, 740.0695419311523) + assert math.alike(o, 740.06955) data0 = [12.0, 7.88, 76.122, 54.83] data1 = [2.0, 5.88, 7.122, 5.83] o = stats.covariance(data0, data1) - assert math.alike(o, 36.65028190612793) + assert math.alike(o, 36.650282000000004) // test for int, i64, f32 array data0_int := [1, 2, 3, 1] @@ -428,13 +428,13 @@ fn test_covariance() { fn test_lag1_autocorrelation() { mut data := [10.0, 4.45, 5.9, 2.7] mut o := stats.lag1_autocorrelation(data) - assert math.alike(o, -0.5542285495255542) + assert math.alike(o, -0.5542285481446095) data = [-3.0, 67.31, 4.4, 1.89] o = stats.lag1_autocorrelation(data) - assert math.alike(o, -0.5102510688760657) + assert math.alike(o, -0.5102510654033415) data = [12.0, 7.88, 76.122, 54.83] o = stats.lag1_autocorrelation(data) - assert math.alike(o, 0.10484451223403927) + assert math.alike(o, 0.10484450460892072) // test for int, i64, f32 array assert stats.lag1_autocorrelation[int]([1, 2, 3, 1]) == 0 @@ -446,13 +446,13 @@ fn test_lag1_autocorrelation() { fn test_kurtosis() { mut data := [10.0, 4.45, 5.9, 2.7] mut o := stats.kurtosis(data) - assert math.alike(o, -1.0443214689384779) + assert math.alike(o, -1.0443212849233845) data = [-3.0, 67.31, 4.4, 1.89] o = stats.kurtosis(data) - assert math.alike(o, -0.688495594786176) + assert math.alike(o, -0.6884953374814851) data = [12.0, 7.88, 76.122, 54.83] o = stats.kurtosis(data) - assert math.alike(o, -1.7323772574195067) + assert math.alike(o, -1.7323772836921467) // test for int, i64, f32 array assert stats.kurtosis[int]([1, 2, 3, 1]) == 1 @@ -464,13 +464,13 @@ fn test_kurtosis() { fn test_skew() { mut data := [10.0, 4.45, 5.9, 2.7] mut o := stats.skew(data) - assert math.alike(o, 0.5754020379048158) + assert math.alike(o, 0.5754021106320453) data = [-3.0, 67.31, 4.4, 1.89] o = stats.skew(data) - assert math.alike(o, 1.1248732608899568) + assert math.alike(o, 1.1248733711136492) data = [12.0, 7.88, 76.122, 54.83] o = stats.skew(data) - assert math.alike(o, 0.19007917421924964) + assert math.alike(o, 0.19007911706827735) // test for int, i64, f32 array assert stats.skew[int]([1, 2, 3, 1]) == 2 @@ -484,13 +484,13 @@ fn test_quantile() { mut data := [2.7, 4.45, 5.9, 10.0] mut o := stats.quantile(data, 0.1)! - assert math.alike(o, 3.225000020861626) + assert math.alike(o, 3.2249999046325684) data = [-3.0, 1.89, 4.4, 67.31] o = stats.quantile(data, 0.2)! - assert math.alike(o, -0.06599988341331486) + assert math.alike(o, -0.06600001454353333) data = [7.88, 12.0, 54.83, 76.122] o = stats.quantile(data, 0.3)! - assert math.alike(o, 11.587999901771546) + assert math.alike(o, 11.588000297546387) stats.quantile(data, -0.3) or { assert err.msg() == 'index out of range' } diff --git a/vlib/v/checker/assign.v b/vlib/v/checker/assign.v index aeee42b65c2463..2c578c354cc837 100644 --- a/vlib/v/checker/assign.v +++ b/vlib/v/checker/assign.v @@ -410,6 +410,11 @@ fn (mut c Checker) assign_stmt(mut node ast.AssignStmt) { left.obj.ct_type_var = .field_var left.obj.typ = c.comptime.comptime_for_field_type } + } else if mut right is ast.InfixExpr { + right_ct_var := c.comptime.get_ct_type_var(right.left) + if right_ct_var in [.generic_var, .generic_param] { + left.obj.ct_type_var = right_ct_var + } } else if mut right is ast.Ident && right.obj is ast.Var && right.or_expr.kind == .absent { right_obj_var := right.obj as ast.Var diff --git a/vlib/v/gen/c/assign.v b/vlib/v/gen/c/assign.v index a62d8b80f4b0bf..922fcf0d009f07 100644 --- a/vlib/v/gen/c/assign.v +++ b/vlib/v/gen/c/assign.v @@ -371,6 +371,14 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) { left.obj.typ = var_type g.assign_ct_type = var_type } + } else if val is ast.InfixExpr { + ctyp := g.unwrap_generic(g.type_resolver.get_type(val.left)) + if ctyp != ast.void_type { + var_type = ctyp + val_type = var_type + left.obj.typ = var_type + g.assign_ct_type = var_type + } } is_auto_heap = left.obj.is_auto_heap } diff --git a/vlib/v/type_resolver/generic_resolver.v b/vlib/v/type_resolver/generic_resolver.v index dbbce60de0a3c0..d4cd21dbf28dfc 100644 --- a/vlib/v/type_resolver/generic_resolver.v +++ b/vlib/v/type_resolver/generic_resolver.v @@ -303,7 +303,7 @@ pub fn (mut t TypeResolver) resolve_args(cur_fn &ast.FnDecl, func &ast.Fn, mut n comptime_args[k] = m.return_type } } - } else if mut call_arg.expr is ast.CastExpr { + } else if mut call_arg.expr is ast.CastExpr && call_arg.expr.typ.has_flag(.generic) { cparam_type_sym := t.table.sym(t.resolver.unwrap_generic(call_arg.expr.typ)) param_typ_sym := t.table.sym(param_typ) if param_typ_sym.kind == .map && cparam_type_sym.info is ast.Map { diff --git a/vlib/v/type_resolver/type_resolver.v b/vlib/v/type_resolver/type_resolver.v index fc0225faa0f937..c74cc58f888ae3 100644 --- a/vlib/v/type_resolver/type_resolver.v +++ b/vlib/v/type_resolver/type_resolver.v @@ -119,6 +119,19 @@ pub fn (mut t TypeResolver) get_type_or_default(node ast.Expr, default_typ ast.T return t.get_type_or_default(node.left, default_typ) } } + ast.IndexExpr { + if node.left is ast.Ident && node.left.ct_expr { + ctyp := t.get_type(node) + if ctyp != ast.void_type { + return ctyp + } + } + } + ast.CastExpr { + if node.typ.has_flag(.generic) { + return t.resolver.unwrap_generic(node.typ) + } + } else { return default_typ } @@ -184,6 +197,12 @@ pub fn (mut t TypeResolver) get_type(node ast.Expr) ast.Type { nltype := t.get_type(node.left) nltype_unwrapped := t.resolver.unwrap_generic(nltype) return t.table.value_type(nltype_unwrapped) + } else if node is ast.ParExpr && t.info.is_comptime(node.expr) { + return t.get_type(node.expr) + } else if node is ast.InfixExpr && t.info.is_comptime(node.left) { + return t.get_type(node.left) + } else if node is ast.CastExpr && node.typ.has_flag(.generic) { + return t.resolver.unwrap_generic(node.typ) } return ast.void_type }