Add multipleOf to FloatSchema

Author: dominikzogg

doc/Schema/FloatSchema.md

@@ -23,6 +23,7 @@ $schema->minimum(5.0);  // Greater than or equal to 5.0
 $schema->exclusiveMinimum(5.0);   // Greater than 5.0
 $schema->exclusiveMaximum(10.0);  // Less than 10.0
 $schema->maximum(10.0); // Less than or equal to 10.0
+$schema->multipleOf(0.5); // Multiple of 0.5
 ```
 
 ### Sign Constraints
@@ -86,4 +87,5 @@ $coordinatesSchema->parse(['lat' => 47.1, 'lng' => 8.2]);
 | `float.exclusiveMinimum` | Value is not greater than to threshold |
 | `float.exclusiveMaximum` | Value is not less than to threshold |
 | `float.maximum` | Value is not less than or equal to threshold |
+| `float.multipleOf` | Value is not a multiple of threshold |
 | `float.int` | Cannot convert float to int without precision loss (for `toInt()`) |

src/Schema/FloatSchema.php

@@ -24,6 +24,9 @@ final class FloatSchema extends AbstractSchemaInnerParse implements SchemaInterf
     public const string ERROR_MAXIMUM_CODE = 'float.maximum';
     public const string ERROR_MAXIMUM_TEMPLATE = 'Value should be maximum {{maximum}}, {{given}} given';
 
+    public const string ERROR_MULTIPLE_OF_CODE = 'float.multipleOf';
+    public const string ERROR_MULTIPLE_OF_TEMPLATE = 'Value should be multiple of {{multipleOf}}, {{given}} given';
+
     /** @deprecated: see ERROR_MINIMUM_CODE */
     public const string ERROR_GTE_CODE = 'float.gte';
 
@@ -119,6 +122,33 @@ public function maximum(float $maximum): static
         });
     }
 
+    public function multipleOf(float $multipleOf): static
+    {
+        if ($multipleOf <= 0.0) {
+            throw new \InvalidArgumentException(
+                \sprintf('Argument #1 ($multipleOf) must be greater than 0, %s given', $multipleOf)
+            );
+        }
+
+        return $this->postParse(static function (float $float) use ($multipleOf) {
+            $quotient = $float / $multipleOf;
+            $roundedQuotient = round($quotient);
+            $epsilon = 10 * PHP_FLOAT_EPSILON * max(1.0, abs($quotient));
+
+            if (abs($quotient - $roundedQuotient) <= $epsilon) {
+                return $float;
+            }
+
+            throw new ErrorsException(
+                new Error(
+                    self::ERROR_MULTIPLE_OF_CODE,
+                    self::ERROR_MULTIPLE_OF_TEMPLATE,
+                    ['multipleOf' => $multipleOf, 'given' => $float]
+                )
+            );
+        });
+    }
+
     /**
      * @deprecated Use minimum($minimum) instead
      */

tests/Unit/Schema/FloatSchemaTest.php

@@ -29,6 +29,7 @@ public function testImmutability(): void
         self::assertNotSame($schema, $schema->exclusiveMinimum(0.0));
         self::assertNotSame($schema, $schema->exclusiveMaximum(0.0));
         self::assertNotSame($schema, $schema->maximum(0.0));
+        self::assertNotSame($schema, $schema->multipleOf(0.1));
     }
 
     public function testParseSuccess(): void
@@ -367,6 +368,117 @@ public function testParseWithInvalidMaximum(): void
         }
     }
 
+    public function testParseWithValidMultipleOf(): void
+    {
+        $input = 0.3;
+        $multipleOf = 0.1;
+
+        $schema = (new FloatSchema())->multipleOf($multipleOf);
+
+        self::assertSame($input, $schema->parse($input));
+    }
+
+    public function testParseWithInvalidMultipleOf(): void
+    {
+        $input = 0.35;
+        $multipleOf = 0.1;
+
+        $schema = (new FloatSchema())->multipleOf($multipleOf);
+
+        try {
+            $schema->parse($input);
+
+            throw new \Exception('code should not be reached');
+        } catch (ErrorsException $errorsException) {
+            self::assertSame([
+                [
+                    'path' => '',
+                    'error' => [
+                        'code' => 'float.multipleOf',
+                        'template' => 'Value should be multiple of {{multipleOf}}, {{given}} given',
+                        'variables' => [
+                            'multipleOf' => $multipleOf,
+                            'given' => $input,
+                        ],
+                    ],
+                ],
+            ], $errorsException->errors->jsonSerialize());
+        }
+    }
+
+    public function testMultipleOfWithInvalidMultipleOf(): void
+    {
+        $this->expectException(\InvalidArgumentException::class);
+        $this->expectExceptionMessage('Argument #1 ($multipleOf) must be greater than 0, 0 given');
+
+        (new FloatSchema())->multipleOf(0.0);
+    }
+
+    public function testParseWithValidMultipleOfTrickyFloatingPointValues(): void
+    {
+        $cases = [
+            [0.3, 0.1],
+            [0.7, 0.1],
+            [0.58, 0.01],
+            [-0.3, 0.1],
+            [1.0E-12, 1.0E-13],
+        ];
+
+        foreach ($cases as [$input, $multipleOf]) {
+            $schema = (new FloatSchema())->multipleOf($multipleOf);
+
+            self::assertSame($input, $schema->parse($input));
+        }
+    }
+
+    public function testParseWithInvalidMultipleOfTrickyFloatingPointValues(): void
+    {
+        $cases = [
+            [0.3000000000001, 0.1],
+            [0.3, 0.2],
+            [1.0E-12, 3.0E-13],
+            [-0.35, 0.1],
+        ];
+
+        foreach ($cases as [$input, $multipleOf]) {
+            $schema = (new FloatSchema())->multipleOf($multipleOf);
+
+            try {
+                $schema->parse($input);
+
+                throw new \Exception('code should not be reached');
+            } catch (ErrorsException $errorsException) {
+                self::assertSame('float.multipleOf', $errorsException->errors->jsonSerialize()[0]['error']['code']);
+            }
+        }
+    }
+
+    public function testParseWithValidMultipleOfAtEpsilonBoundary(): void
+    {
+        $multipleOf = 1.0;
+        $input = 1.0 - 10 * PHP_FLOAT_EPSILON;
+
+        $schema = (new FloatSchema())->multipleOf($multipleOf);
+
+        self::assertSame($input, $schema->parse($input));
+    }
+
+    public function testParseWithInvalidMultipleOfJustAboveEpsilonBoundary(): void
+    {
+        $multipleOf = 1.0;
+        $input = 1.0 - 21 * PHP_FLOAT_EPSILON / 2;
+
+        $schema = (new FloatSchema())->multipleOf($multipleOf);
+
+        try {
+            $schema->parse($input);
+
+            throw new \Exception('code should not be reached');
+        } catch (ErrorsException $errorsException) {
+            self::assertSame('float.multipleOf', $errorsException->errors->jsonSerialize()[0]['error']['code']);
+        }
+    }
+
     public function testParseWithValidGte(): void
     {
         $input = 4.1;