diff --git a/internal/core/convert/go.go b/internal/core/convert/go.go
index aea75da..067321d 100644
--- a/internal/core/convert/go.go
+++ b/internal/core/convert/go.go
@@ -275,8 +275,16 @@
 		return n
 
 	case *apd.Decimal:
-		// TODO: set num or float based on value of number.
-		n := &adt.Num{Src: ctx.Source(), K: adt.NumKind}
+		// TODO: should we allow an "int" bit to be set here? It is a bit
+		// tricky, as we would also need to pass down the result of rounding.
+		// So more likely an API must return explicitly whether a value is
+		// a float or an int after all.
+		// The code to autodetect whether something is an integer can be done
+		// with this:
+		// var d apd.Decimal
+		// res, _ := apd.BaseContext.RoundToIntegralExact(&d, v)
+		// integer := !res.Inexact()
+		n := &adt.Num{Src: ctx.Source(), K: adt.FloatKind}
 		n.X = *v
 		return n
 
diff --git a/pkg/list/testdata/gen.txtar b/pkg/list/testdata/gen.txtar
index 2061db7..06f6daa 100644
--- a/pkg/list/testdata/gen.txtar
+++ b/pkg/list/testdata/gen.txtar
@@ -93,7 +93,7 @@
 Result:
 (_|_){
   // [eval]
-  t1: (number){ 2.5 }
+  t1: (float){ 2.5 }
   t2: (_|_){
     // [eval] error in call to list.Avg: empty list
   }
@@ -161,7 +161,7 @@
     // [eval] t14: cannot use "foo" (type string) as int in argument 2 to list.FlattenN:
     //     ./in.cue:16:24
   }
-  t15: (number){ 4 }
+  t15: (float){ 4 }
   t16: (_|_){
     // [eval] error in call to list.Max: empty list
   }
@@ -169,7 +169,7 @@
     // [eval] t17: cannot use "foo" (type string) as list in argument 1 to list.Max:
     //     ./in.cue:19:15
   }
-  t18: (number){ 1 }
+  t18: (float){ 1 }
   t19: (_|_){
     // [eval] error in call to list.Min: empty list
   }
@@ -177,8 +177,8 @@
     // [eval] t20: cannot use "foo" (type string) as list in argument 1 to list.Min:
     //     ./in.cue:22:15
   }
-  t21: (number){ 24 }
-  t22: (number){ 1 }
+  t21: (float){ 24 }
+  t22: (float){ 1 }
   t23: (_|_){
     // [eval] t23: cannot use "foo" (type string) as list in argument 1 to list.Product:
     //     ./in.cue:25:19
@@ -193,38 +193,38 @@
     // [eval] error in call to list.Range: end must be less than start when step is negative
   }
   t27: (#list){
-    0: (number){ 0 }
-    1: (number){ 1 }
-    2: (number){ 2 }
-    3: (number){ 3 }
-    4: (number){ 4 }
+    0: (float){ 0 }
+    1: (float){ 1 }
+    2: (float){ 2 }
+    3: (float){ 3 }
+    4: (float){ 4 }
   }
   t28: (#list){
-    0: (number){ 0 }
+    0: (float){ 0 }
   }
   t29: (#list){
-    0: (number){ 0 }
-    1: (number){ 2 }
-    2: (number){ 4 }
+    0: (float){ 0 }
+    1: (float){ 2 }
+    2: (float){ 4 }
   }
   t30: (#list){
-    0: (number){ 5 }
-    1: (number){ 4 }
-    2: (number){ 3 }
-    3: (number){ 2 }
-    4: (number){ 1 }
+    0: (float){ 5 }
+    1: (float){ 4 }
+    2: (float){ 3 }
+    3: (float){ 2 }
+    4: (float){ 1 }
   }
   t31: (#list){
-    0: (number){ 0 }
-    1: (number){ 0.5 }
-    2: (number){ 1.0 }
-    3: (number){ 1.5 }
-    4: (number){ 2.0 }
-    5: (number){ 2.5 }
-    6: (number){ 3.0 }
-    7: (number){ 3.5 }
-    8: (number){ 4.0 }
-    9: (number){ 4.5 }
+    0: (float){ 0 }
+    1: (float){ 0.5 }
+    2: (float){ 1.0 }
+    3: (float){ 1.5 }
+    4: (float){ 2.0 }
+    5: (float){ 2.5 }
+    6: (float){ 3.0 }
+    7: (float){ 3.5 }
+    8: (float){ 4.0 }
+    9: (float){ 4.5 }
   }
   t32: (#list){
     0: (int){ 2 }
@@ -274,8 +274,8 @@
   t42: (_|_){
     // [eval] 0: error in call to list.SortStrings: element 0 of list argument 0: cannot use value 1 (type int) as string
   }
-  t43: (number){ 10 }
-  t44: (number){ 0 }
+  t43: (float){ 10 }
+  t44: (float){ 0 }
   t45: (_|_){
     // [eval] t45: cannot use "foo" (type string) as list in argument 1 to list.Sum:
     //     ./in.cue:51:15
diff --git a/pkg/math/manual.go b/pkg/math/manual.go
index 80e3cf7..dd77ddd 100644
--- a/pkg/math/manual.go
+++ b/pkg/math/manual.go
@@ -15,21 +15,42 @@
 package math
 
 import (
+	"math/big"
+
 	"github.com/cockroachdb/apd/v2"
 
 	"cuelang.org/go/internal"
 )
 
+func roundContext(rounder string) *apd.Context {
+	c := *apdContext
+	c.Rounding = rounder
+	return &c
+}
+
+// TODO: for now we convert Decimals to int. This allows the desired type to be
+// conveyed. This has the disadvantage tht a number like 1E10000 will need to be
+// expanded. Eventually it would be better to to unify number types and allow
+// anything that results in an integer to pose as an integer type.
+func toInt(d *internal.Decimal) *big.Int {
+	i := &d.Coeff
+	if d.Negative {
+		i.Neg(i)
+	}
+	return i
+}
+
 // Floor returns the greatest integer value less than or equal to x.
 //
 // Special cases are:
 //	Floor(±0) = ±0
 //	Floor(±Inf) = ±Inf
 //	Floor(NaN) = NaN
-func Floor(x *internal.Decimal) (*internal.Decimal, error) {
+func Floor(x *internal.Decimal) (*big.Int, error) {
 	var d internal.Decimal
 	_, err := apdContext.Floor(&d, x)
-	return &d, err
+	_, _ = apdContext.Quantize(&d, &d, 0)
+	return toInt(&d), err
 }
 
 // Ceil returns the least integer value greater than or equal to x.
@@ -38,13 +59,14 @@
 //	Ceil(±0) = ±0
 //	Ceil(±Inf) = ±Inf
 //	Ceil(NaN) = NaN
-func Ceil(x *internal.Decimal) (*internal.Decimal, error) {
+func Ceil(x *internal.Decimal) (*big.Int, error) {
 	var d internal.Decimal
 	_, err := apdContext.Ceil(&d, x)
-	return &d, err
+	_, _ = apdContext.Quantize(&d, &d, 0)
+	return toInt(&d), err
 }
 
-var roundTruncContext = apd.Context{Rounding: apd.RoundDown}
+var roundTruncContext = roundContext(apd.RoundDown)
 
 // Trunc returns the integer value of x.
 //
@@ -52,13 +74,13 @@
 //	Trunc(±0) = ±0
 //	Trunc(±Inf) = ±Inf
 //	Trunc(NaN) = NaN
-func Trunc(x *internal.Decimal) (*internal.Decimal, error) {
+func Trunc(x *internal.Decimal) (*big.Int, error) {
 	var d internal.Decimal
 	_, err := roundTruncContext.RoundToIntegralExact(&d, x)
-	return &d, err
+	return toInt(&d), err
 }
 
-var roundUpContext = apd.Context{Rounding: apd.RoundHalfUp}
+var roundUpContext = roundContext(apd.RoundHalfUp)
 
 // Round returns the nearest integer, rounding half away from zero.
 //
@@ -66,13 +88,13 @@
 //	Round(±0) = ±0
 //	Round(±Inf) = ±Inf
 //	Round(NaN) = NaN
-func Round(x *internal.Decimal) (*internal.Decimal, error) {
+func Round(x *internal.Decimal) (*big.Int, error) {
 	var d internal.Decimal
 	_, err := roundUpContext.RoundToIntegralExact(&d, x)
-	return &d, err
+	return toInt(&d), err
 }
 
-var roundEvenContext = apd.Context{Rounding: apd.RoundHalfEven}
+var roundEvenContext = roundContext(apd.RoundHalfEven)
 
 // RoundToEven returns the nearest integer, rounding ties to even.
 //
@@ -80,10 +102,10 @@
 //	RoundToEven(±0) = ±0
 //	RoundToEven(±Inf) = ±Inf
 //	RoundToEven(NaN) = NaN
-func RoundToEven(x *internal.Decimal) (*internal.Decimal, error) {
+func RoundToEven(x *internal.Decimal) (*big.Int, error) {
 	var d internal.Decimal
 	_, err := roundEvenContext.RoundToIntegralExact(&d, x)
-	return &d, err
+	return toInt(&d), err
 }
 
 var mulContext = apd.BaseContext.WithPrecision(1)
diff --git a/pkg/math/pkg.go b/pkg/math/pkg.go
index c079314..4c2c086 100644
--- a/pkg/math/pkg.go
+++ b/pkg/math/pkg.go
@@ -69,7 +69,7 @@
 	}, {
 		Name:   "Floor",
 		Params: []adt.Kind{adt.NumKind},
-		Result: adt.NumKind,
+		Result: adt.IntKind,
 		Func: func(c *internal.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
@@ -79,7 +79,7 @@
 	}, {
 		Name:   "Ceil",
 		Params: []adt.Kind{adt.NumKind},
-		Result: adt.NumKind,
+		Result: adt.IntKind,
 		Func: func(c *internal.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
@@ -89,7 +89,7 @@
 	}, {
 		Name:   "Trunc",
 		Params: []adt.Kind{adt.NumKind},
-		Result: adt.NumKind,
+		Result: adt.IntKind,
 		Func: func(c *internal.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
@@ -99,7 +99,7 @@
 	}, {
 		Name:   "Round",
 		Params: []adt.Kind{adt.NumKind},
-		Result: adt.NumKind,
+		Result: adt.IntKind,
 		Func: func(c *internal.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
@@ -109,7 +109,7 @@
 	}, {
 		Name:   "RoundToEven",
 		Params: []adt.Kind{adt.NumKind},
-		Result: adt.NumKind,
+		Result: adt.IntKind,
 		Func: func(c *internal.CallCtxt) {
 			x := c.Decimal(0)
 			if c.Do() {
diff --git a/pkg/math/testdata/gen.txtar b/pkg/math/testdata/gen.txtar
index aa29913..6f449bf 100644
--- a/pkg/math/testdata/gen.txtar
+++ b/pkg/math/testdata/gen.txtar
@@ -6,25 +6,12 @@
 t1: math.Pi
 t2: math.Floor(math.Pi)
 t3: math.Pi(3)
-t4: math.Floor(3, 5)
-t5: math.Floor("foo")
 t6: math.Jacobi(1000, 2000)
 t7: math.Jacobi(1000, 201)
 t8: math.Asin(2.0e400)
-t9: math.MultipleOf(4, 2)
-t10: math.MultipleOf(5, 2)
-t11: math.MultipleOf(5, 0)
-t12: math.MultipleOf(100, 1.00001)
-t13: math.MultipleOf(1, 1)
-t14: math.MultipleOf(5, 2.5)
-t15: math.MultipleOf(100e100, 10)
 t16: math.Pow(8, 4)
 t17: math.Pow10(4)
 t18: math.Signbit(-4)
-t19: math.Round(2.5)
-t20: math.Round(-2.5)
-t21: math.RoundToEven(2.5)
-t22: math.RoundToEven(-2.5)
 t23: math.Abs(2.5)
 t24: math.Abs(-2.2)
 t25: math.Cbrt(2)
@@ -36,81 +23,43 @@
 t31: math.Log2(5)
 t32: math.Dim(3, 2.5)
 t33: math.Dim(5, 7.2)
-t34: math.Ceil(2.5)
-t35: math.Ceil(-2.2)
-t36: math.Floor(2.9)
-t37: math.Floor(-2.2)
-t38: math.Trunc(2.5)
-t39: math.Trunc(-2.9)
 -- out/math --
 Errors:
 error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000
-error in call to math.MultipleOf: division by zero
 t3: cannot call non-function math.Pi (type float):
     ./in.cue:5:5
-t4: too many arguments in call to math.Floor (have 2, want 1):
-    ./in.cue:6:20
-t5: cannot use "foo" (type string) as number in argument 1 to math.Floor:
-    ./in.cue:7:16
 cannot use 2.0E+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up:
-    ./in.cue:10:5
+    ./in.cue:8:5
 
 Result:
 (_|_){
   // [eval]
   t1: (float){ 3.14159265358979323846264338327950288419716939937510582097494459 }
-  t2: (number){ 3 }
+  t2: (int){ 3 }
   t3: (_|_){
     // [eval] t3: cannot call non-function math.Pi (type float):
     //     ./in.cue:5:5
   }
-  t4: (_|_){
-    // [eval] t4: too many arguments in call to math.Floor (have 2, want 1):
-    //     ./in.cue:6:20
-  }
-  t5: (_|_){
-    // [eval] t5: cannot use "foo" (type string) as number in argument 1 to math.Floor:
-    //     ./in.cue:7:16
-  }
   t6: (_|_){
     // [eval] error in call to math.Jacobi: big: invalid 2nd argument to Int.Jacobi: need odd integer but got 2000
   }
   t7: (int){ 1 }
   t8: (_|_){
     // [eval] cannot use 2.0E+400 (type float) as float64 in argument 0 to math.Asin: value was rounded up:
-    //     ./in.cue:10:5
+    //     ./in.cue:8:5
   }
-  t9: (bool){ true }
-  t10: (bool){ false }
-  t11: (_|_){
-    // [eval] error in call to math.MultipleOf: division by zero
-  }
-  t12: (bool){ false }
-  t13: (bool){ true }
-  t14: (bool){ true }
-  t15: (bool){ true }
-  t16: (number){ 4096 }
-  t17: (number){ 1E+4 }
+  t16: (float){ 4096 }
+  t17: (float){ 1E+4 }
   t18: (bool){ true }
-  t19: (number){ 3 }
-  t20: (number){ -3 }
-  t21: (number){ 2 }
-  t22: (number){ -2 }
-  t23: (number){ 2.5 }
-  t24: (number){ 2.2 }
-  t25: (number){ 1.25992104989487316476721 }
-  t26: (number){ -5 }
-  t27: (number){ 20.0855369231876677409285 }
-  t28: (number){ 11.3137084989847603904135 }
-  t29: (number){ 1.38629436111989061883446 }
-  t30: (number){ 0.602059991327962390427478 }
-  t31: (number){ 2.32192809488736234787032 }
-  t32: (number){ 0.5 }
-  t33: (number){ 0 }
-  t34: (number){ 3 }
-  t35: (number){ -2 }
-  t36: (number){ 2 }
-  t37: (number){ -3 }
-  t38: (number){ 2 }
-  t39: (number){ -2 }
+  t23: (float){ 2.5 }
+  t24: (float){ 2.2 }
+  t25: (float){ 1.25992104989487316476721 }
+  t26: (float){ -5 }
+  t27: (float){ 20.0855369231876677409285 }
+  t28: (float){ 11.3137084989847603904135 }
+  t29: (float){ 1.38629436111989061883446 }
+  t30: (float){ 0.602059991327962390427478 }
+  t31: (float){ 2.32192809488736234787032 }
+  t32: (float){ 0.5 }
+  t33: (float){ 0 }
 }
diff --git a/pkg/math/testdata/issue418.txtar b/pkg/math/testdata/issue418.txtar
new file mode 100644
index 0000000..fba9bb9
--- /dev/null
+++ b/pkg/math/testdata/issue418.txtar
@@ -0,0 +1,33 @@
+-- in.cue --
+import "math"
+
+a: {
+    x: 32.45
+    y: int
+    y: math.Round(x)
+}
+
+b: {
+    x: 32.45
+    y: int
+    y: math.Log(x)
+}
+-- out/math --
+Errors:
+b.y: conflicting values int and 3.47970044315009900124277 (mismatched types int and float)
+
+Result:
+(_|_){
+  // [eval]
+  a: (struct){
+    x: (float){ 32.45 }
+    y: (int){ 32 }
+  }
+  b: (_|_){
+    // [eval]
+    x: (float){ 32.45 }
+    y: (_|_){
+      // [eval] b.y: conflicting values int and 3.47970044315009900124277 (mismatched types int and float)
+    }
+  }
+}
diff --git a/pkg/math/testdata/round.txtar b/pkg/math/testdata/round.txtar
new file mode 100644
index 0000000..b1eda54
--- /dev/null
+++ b/pkg/math/testdata/round.txtar
@@ -0,0 +1,76 @@
+# generated from the original tests.
+# Henceforth it may be nicer to group tests into separate files.
+-- in.cue --
+import "math"
+
+mul0: math.MultipleOf(4, 2)
+mul1: math.MultipleOf(5, 2)
+// TODO(errors): ensure path is included for the following error.
+mul2: math.MultipleOf(5, 0)
+mul3: math.MultipleOf(100, 1.00001)
+mul4: math.MultipleOf(1, 1)
+mul5: math.MultipleOf(5, 2.5)
+mul6: math.MultipleOf(100e100, 10)
+
+r0: math.Round(2.5)
+r1: math.Round(-2.5)
+r2: math.RoundToEven(2.5)
+r3: math.RoundToEven(-2.5)
+
+floorE1: math.Floor(3, 5)
+floorE2: math.Floor("foo")
+
+floor0: math.Floor(math.Pi)
+floor1: math.Floor(2.9)
+floor2: math.Floor(-2.2)
+floor3: math.Floor(2900)
+floor4: math.Floor(29E2)
+
+ceil0: math.Ceil(2.5)
+ceil1: math.Ceil(-2.2)
+
+trunc0: math.Trunc(2.5)
+trunc1: math.Trunc(-2.9)
+
+-- out/math --
+Errors:
+error in call to math.MultipleOf: division by zero
+floorE1: too many arguments in call to math.Floor (have 2, want 1):
+    ./in.cue:17:25
+floorE2: cannot use "foo" (type string) as number in argument 1 to math.Floor:
+    ./in.cue:18:21
+
+Result:
+(_|_){
+  // [eval]
+  mul0: (bool){ true }
+  mul1: (bool){ false }
+  mul2: (_|_){
+    // [eval] error in call to math.MultipleOf: division by zero
+  }
+  mul3: (bool){ false }
+  mul4: (bool){ true }
+  mul5: (bool){ true }
+  mul6: (bool){ true }
+  r0: (int){ 3 }
+  r1: (int){ -3 }
+  r2: (int){ 2 }
+  r3: (int){ -2 }
+  floorE1: (_|_){
+    // [eval] floorE1: too many arguments in call to math.Floor (have 2, want 1):
+    //     ./in.cue:17:25
+  }
+  floorE2: (_|_){
+    // [eval] floorE2: cannot use "foo" (type string) as number in argument 1 to math.Floor:
+    //     ./in.cue:18:21
+  }
+  floor0: (int){ 3 }
+  floor1: (int){ 2 }
+  floor2: (int){ -3 }
+  floor3: (int){ 2900 }
+  floor4: (int){ 2900 }
+  ceil0: (int){ 3 }
+  ceil1: (int){ -2 }
+  trunc0: (int){ 2 }
+  trunc1: (int){ -2 }
+}