diff --git a/Source/Bogus.Tests/GitHubIssues/Issue422.cs b/Source/Bogus.Tests/GitHubIssues/Issue422.cs
new file mode 100644
index 00000000..11e1dfef
--- /dev/null
+++ b/Source/Bogus.Tests/GitHubIssues/Issue422.cs
@@ -0,0 +1,70 @@
+using Xunit;
+using FluentAssertions;
+using FluentAssertions.Execution;
+using Z.ExtensionMethods;
+
+namespace Bogus.Tests.GitHubIssues
+{
+   public class Issue422
+   {
+      private Randomizer sut;
+
+      public Issue422()
+      {
+         sut = new Randomizer();
+      }
+
+      /// <summary>
+      /// Verifies that generating a random <see cref="double"/>
+      /// between <see cref="double.MinValue"/> 
+      /// and <see cref="double.MaxValue"/>
+      /// yields a non-symbolic, valid value in that range.
+      /// See issue #422.
+      /// </summary>
+      [Fact]
+      public void generate_any_valid_double()
+      {
+         var result = sut.Double(double.MinValue, double.MaxValue);
+
+         using (new AssertionScope())
+         {
+            result.Should().BeInRange(double.MinValue, double.MaxValue);
+            result.IsNaN().Should().BeFalse();
+            result.IsInfinity().Should().BeFalse();
+         }
+      }
+
+      /// <summary>
+      /// Verifies that generating a random <see cref="decimal"/>
+      /// between <see cref="decimal.MinValue"/> 
+      /// and <see cref="decimal.MaxValue"/>
+      /// yields a non-symbolic, valid value in that range.
+      /// See issue #422.
+      /// </summary>
+      [Fact]
+      public void generate_any_valid_decimal()
+      {
+         sut.Decimal(decimal.MinValue, decimal.MaxValue).Should().BeInRange(decimal.MinValue, decimal.MaxValue);
+      }
+
+      /// <summary>
+      /// Verifies that generating a random <see cref="float"/>
+      /// between <see cref="float.MinValue"/> 
+      /// and <see cref="float.MaxValue"/>
+      /// yields a non-symbolic, valid value in that range.
+      /// See issue #422.
+      /// </summary>
+      [Fact]
+      public void generate_any_valid_float()
+      {
+         var result = sut.Float(float.MinValue, float.MaxValue);
+
+         using (new AssertionScope())
+         {
+            result.Should().BeInRange(float.MinValue, float.MaxValue);
+            result.IsNaN().Should().BeFalse();
+            result.IsInfinity().Should().BeFalse();
+         }
+      }
+   }
+}
diff --git a/Source/Bogus/Randomizer.cs b/Source/Bogus/Randomizer.cs
index 76fe7c5c..e723dbad 100644
--- a/Source/Bogus/Randomizer.cs
+++ b/Source/Bogus/Randomizer.cs
@@ -180,13 +180,16 @@ public double Double(double min = 0.0d, double max = 1.0d)
          //lock any seed access, for thread safety.
          lock( Locker.Value )
          {
+            var unscaled = localSeed.NextDouble();
+
             if( min == 0.0d && max == 1.0d )
             {
                //use default implementation
-               return localSeed.NextDouble();
+               return unscaled;
             }
 
-            return localSeed.NextDouble() * (max - min) + min;
+            //otherwise, scale the value
+            return (max * unscaled) + (min * (1.0d - unscaled));
          }
       }
 
@@ -197,7 +200,16 @@ public double Double(double min = 0.0d, double max = 1.0d)
       /// <param name="max">Maximum, default 1.0</param>
       public decimal Decimal(decimal min = 0.0m, decimal max = 1.0m)
       {
-         return Convert.ToDecimal(Double()) * (max - min) + min;
+         var unscaled = Convert.ToDecimal(Double());
+
+         if (min == 0.0m && max == 1.0m)
+         {
+            //use default implementation
+            return unscaled;
+         }
+
+         //otherwise, scale the value
+         return (max * unscaled) + (min * (1.0m - unscaled));
       }
 
       /// <summary>
@@ -207,7 +219,16 @@ public decimal Decimal(decimal min = 0.0m, decimal max = 1.0m)
       /// <param name="max">Maximum, default 1.0</param>
       public float Float(float min = 0.0f, float max = 1.0f)
       {
-         return Convert.ToSingle(Double() * (max - min) + min);
+         var unscaled = Double();
+
+         if (min == 0.0f && max == 1.0f)
+         {
+            //use default implementation
+            return Convert.ToSingle(unscaled);
+         }
+
+         //otherwise, scale the value
+         return Convert.ToSingle((max * unscaled) + (min * (1.0f - unscaled)));
       }
 
       /// <summary>