Merge pull request #1280 from yueyinqiu/1279

correct torch.finfo

Author: NiklasGustafsson

RELEASENOTES.md

@@ -4,6 +4,10 @@ Releases, starting with 9/2/2021, are listed with the most recent release at the
 
 # NuGet Version 0.102.4
 
+__Breaking Changes__:
+
+Correct `torch.finfo`. (`torch.set_default_dtype`, `Categorical.entropy`, `_CorrCholesky.check`, `Distribution.ClampProbs`, `FisherSnedecor.rsample`, `Gamma.rsample`, `Geometric.rsample`, `distributions.Gumbel`, `Laplace.rsample`, `SigmoidTransform._call` and `SigmoidTransform._inverse` are influenced.)<br/>
+
 __API Changes__:
 
 #1284 make `torch.unique` and `torch.unique_consecutive` public.<br/>

src/TorchSharp/Tensor/Tensor.cs

@@ -7226,37 +7226,63 @@ public struct FInfo
             public double max;
             public double min;
             public double tiny;
+            public double smallest_normal;
+            public double resolution;
         }
 
-        public static FInfo finfo(ScalarType dtype)
+        public static FInfo finfo()
         {
-            if (!is_floating_point(dtype) && !is_complex(dtype))
-                throw new ArgumentException("'dtype' must be floating point or complex");
-
-            if (dtype == ScalarType.ComplexFloat32)
-                dtype = ScalarType.Float32;
-            if (dtype == ScalarType.ComplexFloat64)
-                dtype = ScalarType.Float64;
-
-            FInfo result = new FInfo();
+            return finfo(default_dtype);
+        }
 
+        public static FInfo finfo(ScalarType dtype)
+        {
             switch (dtype) {
+            case ScalarType.BFloat16:
+                return new FInfo() {
+                    bits = 16,
+                    eps = 0.0078125,
+                    max = 3.3895313892515355e+38,
+                    min = -3.3895313892515355e+38,
+                    tiny = 1.1754943508222875e-38,
+                    smallest_normal = 1.1754943508222875e-38,
+                    resolution = 0.01
+                };
+            case ScalarType.Float16:
+                return new FInfo() {
+                    bits = 16,
+                    eps = 0.0009765625,
+                    max = 65504.0,
+                    min = -65504.0,
+                    tiny = 6.103515625e-05,
+                    smallest_normal = 6.103515625e-05,
+                    resolution = 0.001
+                };
             case ScalarType.Float32:
-                result.bits = 32;
-                result.min = float.MinValue;
-                result.max = float.MaxValue;
-                result.eps = float.Epsilon;
-                result.tiny = float.Epsilon;
-                break;
+            case ScalarType.ComplexFloat32:
+                return new FInfo() {
+                    bits = 32,
+                    eps = 1.1920928955078125e-07,
+                    max = 3.4028234663852886e+38,
+                    min = -3.4028234663852886e+38,
+                    tiny = 1.1754943508222875e-38,
+                    smallest_normal = 1.1754943508222875e-38,
+                    resolution = 1e-06
+                };
             case ScalarType.Float64:
-                result.bits = 64;
-                result.min = double.MinValue;
-                result.max = double.MaxValue;
-                result.eps = double.Epsilon;
-                result.tiny = double.Epsilon;
-                break;
-            }
-            return result;
+            case ScalarType.ComplexFloat64:
+                return new FInfo() {
+                    bits = 64,
+                    eps = 2.220446049250313e-16,
+                    max = 1.7976931348623157e+308,
+                    min = -1.7976931348623157e+308,
+                    tiny = 2.2250738585072014e-308,
+                    smallest_normal = 2.2250738585072014e-308,
+                    resolution = 1e-15
+                };
+            default:
+                throw new ArgumentException("'dtype' must be floating point or complex");
+            }
         }
 
         public static bool is_integral(ScalarType type)

src/TorchSharp/Tensor/torch.Tensors.cs

@@ -46,7 +46,13 @@ public static partial class torch
         /// The default floating point dtype is initially torch.float32.
         /// </summary>
         /// <param name="dtype"></param>
-        public static void set_default_dtype(ScalarType dtype) { default_dtype = dtype; }
+        public static void set_default_dtype(ScalarType dtype)
+        {
+            if (!dtype.IsFloatingPoint()) {
+                throw new ArgumentException("only floating-point types are supported as the default type");
+            }
+            default_dtype = dtype;
+        }
 
         // https://pytorch.org/docs/stable/generated/torch.get_default_dtype
         /// <summary>

test/TorchSharpTest/TestTorchSharp.cs

@@ -15,6 +15,70 @@ namespace TorchSharp
     [Collection("Sequential")]
     public class TestTorch
     {
+        [Fact]
+        public void FInfoTest()
+        {
+            static void AssertScalarEqual(Tensor expected, Tensor actual)
+            {
+                Assert.Equal((double)expected, (double)actual);
+            }
+            static void AssertScalarNotEqual(Tensor expected, Tensor actual)
+            {
+                Assert.NotEqual((double)expected, (double)actual);
+            }
+
+            var floatingTypes = new[] {
+                ScalarType.Float16, ScalarType.Float32, ScalarType.Float64, ScalarType.BFloat16
+            };
+            foreach (var scalarType in floatingTypes) {
+                var info = finfo(scalarType);
+
+                var zeroPointFour = tensor(0.4, scalarType);
+                var zeroPointNine = tensor(0.9, scalarType);
+                var one = tensor(1, scalarType);
+                var zero = tensor(1, scalarType);
+                Assert.Equal(one.dtype.ElementSize() * 8, info.bits);
+                
+                var eps = tensor(info.eps, scalarType);
+                AssertScalarNotEqual(one, one + eps);
+                AssertScalarEqual(one + eps, one + eps * zeroPointNine);
+                AssertScalarEqual(one, one + eps * zeroPointFour);
+
+                var max = tensor(info.max, scalarType);
+                AssertScalarEqual(max, max + eps);
+
+                var min = tensor(info.min, scalarType);
+                AssertScalarEqual(-max, min);
+                AssertScalarEqual(min, min - eps);
+
+                var tiny = tensor(info.tiny, scalarType);
+                // not sure how to test for tiny.
+
+                var smallest_normal = tensor(info.smallest_normal, scalarType);
+                AssertScalarEqual(tiny, smallest_normal);
+
+                var resolution = tensor(info.resolution, scalarType);
+                // not sure how to test for resolution.
+            }
+
+            var complexTypes = new[] {
+                (ScalarType.ComplexFloat32, ScalarType.Float32),
+                (ScalarType.ComplexFloat64, ScalarType.Float64)
+            };
+            foreach (var (complex, floating) in complexTypes) {
+                var c = finfo(complex);
+                var f = finfo(floating);
+
+                Assert.Equal(f.bits, c.bits);
+                Assert.Equal(f.eps, c.eps);
+                Assert.Equal(f.max, c.max);
+                Assert.Equal(f.min, c.min);
+                Assert.Equal(f.tiny, c.tiny);
+                Assert.Equal(f.smallest_normal, c.smallest_normal);
+                Assert.Equal(f.resolution, c.resolution);
+            }
+        }
+
         [Fact]
         public void EnumEquivalence()
         {