Skip to content

feat: Performance improvements #59

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 8 commits into from
Oct 17, 2025
Merged

feat: Performance improvements #59

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
5d196e0
Refactor array comparison logic for improved handling of empty arrays…
rogervila Sep 12, 2025
c96724e
Update parameter type for $array2 to mixed and optimize array key checks
rogervila Sep 12, 2025
ad3e18e
Merge branch 'master' into feat-improvements
rogervila Sep 12, 2025
90c90bc
fix: Improve float comparison logic with epsilon handling and add edg…
rogervila Sep 12, 2025
7b154cb
fix: Optimize float comparison handling and improve code readability
rogervila Sep 12, 2025
cf1acc0
fix: Handle PHP_FLOAT_MAX definition in edge case tests for infinity …
rogervila Sep 12, 2025
ec83997
Merge branch 'master' into feat-improvements
rogervila Oct 17, 2025
05bb3ab
fix: tighten performance regression threshold from ±10% to ±2% in ben…
rogervila Oct 17, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions .github/workflows/benchmark.yml
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -82,7 +82,7 @@ jobs:
--retry-threshold=5 \
--iterations=10 \
--tag=pr \
--assert="mode(variant.time.avg) <= mode(baseline.time.avg) +/- 10%" \
--assert="mode(variant.time.avg) <= mode(baseline.time.avg) +/- 2%" \
| tee benchmark-comparison.txt
continue-on-error: true

Expand All @@ -95,7 +95,7 @@ jobs:
const fs = require('fs');
const results = fs.readFileSync('benchmark-comparison.txt', 'utf8');

const body = `## 📊 Benchmark Results\n\n\`\`\`\n${results}\n\`\`\`\n\n**Note:** Benchmarks compare PR against \`${{ github.base_ref }}\` branch.\nPerformance regression threshold: ±10%`;
const body = `## 📊 Benchmark Results\n\n\`\`\`\n${results}\n\`\`\`\n\n**Note:** Benchmarks compare PR against \`${{ github.base_ref }}\` branch.\nPerformance regression threshold: ±2%`;

github.rest.issues.createComment({
issue_number: context.issue.number,
Expand Down
58 changes: 41 additions & 17 deletions src/ArrayDiffMultidimensional.php
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@ class ArrayDiffMultidimensional
* $strict variable defines if comparison must be strict or not
*
* @param array $array1
* @param array $array2
* @param mixed $array2
* @param bool $strict
*
* @return array
Expand All @@ -24,34 +24,58 @@ public static function compare($array1, $array2, $strict = true)
return $array1;
}

$result = array();
$result = [];

foreach ($array1 as $key => $value) {
if (!array_key_exists($key, $array2)) {
// Use isset for better performance, fall back to array_key_exists for null values
if (!isset($array2[$key]) && !array_key_exists($key, $array2)) {
$result[$key] = $value;
continue;
}

if (is_array($value) && count($value) > 0) {
$recursiveArrayDiff = static::compare($value, $array2[$key], $strict);
$value2 = $array2[$key];

if (count($recursiveArrayDiff) > 0) {
$result[$key] = $recursiveArrayDiff;
if (is_array($value)) {
if (empty($value)) {
if (!is_array($value2) || !empty($value2)) {
$result[$key] = $value;
}
continue;
}

// Only recurse if both are arrays
if (is_array($value2)) {
$recursiveArrayDiff = static::compare($value, $value2, $strict);
if (!empty($recursiveArrayDiff)) {
$result[$key] = $recursiveArrayDiff;
}
} else {
$result[$key] = $value;
}
continue;
}

$value1 = $value;
$value2 = $array2[$key];

if ($strict ? is_float($value1) && is_float($value2) : is_float($value1) || is_float($value2)) {
$value1 = (string) $value1;
$value2 = (string) $value2;
}

if ($strict ? $value1 !== $value2 : $value1 != $value2) {
$result[$key] = $value;
// Handle scalar value comparison optimization
if ($strict) {
// Strict comparison - optimize float handling
if (is_float($value) && is_float($value2)) {
// Use epsilon comparison for float precision
$epsilon = defined('PHP_FLOAT_EPSILON') ? PHP_FLOAT_EPSILON : 2.2204460492503E-16;
if (abs($value - $value2) > $epsilon) {
$result[$key] = $value;
}
} elseif ($value !== $value2) {
$result[$key] = $value;
}
} else {
// Loose comparison - convert if either is float
if (is_float($value) || is_float($value2)) {
if ((string) $value != (string) $value2) {
$result[$key] = $value;
}
} elseif ($value != $value2) {
$result[$key] = $value;
}
}
}

Expand Down
37 changes: 15 additions & 22 deletions tests/ArrayCompareTest.php
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -277,37 +277,30 @@ public function it_does_not_detect_loose_changes_without_strict_mode()
/** @test */
public function it_detects_epsilon_change_with_strict_mode()
{
if (defined('PHP_FLOAT_EPSILON')) {
$diff = new ArrayDiffMultidimensional();
$epsilon = defined('PHP_FLOAT_EPSILON') ? PHP_FLOAT_EPSILON : 2.2204460492503E-16;

$new = [123];
$old = [PHP_FLOAT_EPSILON + 123];
$diff = new ArrayDiffMultidimensional();

$this->assertEquals(1, count($diff->compare($new, $old)));
$this->assertTrue(isset($diff->compare($new, $old)[0]));
$this->assertTrue(is_int($diff->compare($new, $old)[0]));
$this->assertEquals(123, $diff->compare($new, $old)[0]);
} else {
var_dump('Skipped since current PHP version does not have PHP_FLOAT_EPSILON defined');
$this->assertTrue(true);
}
$new = [123];
$old = [$epsilon + 123];

$this->assertEquals(1, count($diff->compare($new, $old)));
$this->assertTrue(isset($diff->compare($new, $old)[0]));
$this->assertTrue(is_int($diff->compare($new, $old)[0]));
$this->assertEquals(123, $diff->compare($new, $old)[0]);
}

/** @test */
public function it_does_not_detect_epsilon_change_with_strict_mode()
{
if (defined('PHP_FLOAT_EPSILON')) {
$diff = new ArrayDiffMultidimensional();
$epsilon = defined('PHP_FLOAT_EPSILON') ? PHP_FLOAT_EPSILON : 2.2204460492503E-16;
$diff = new ArrayDiffMultidimensional();

$new = [123];
$old = [PHP_FLOAT_EPSILON + 123];
$new = [123];
$old = [$epsilon + 123];

$this->assertEquals(0, count($diff->looseComparison($new, $old)));
$this->assertFalse(isset($diff->looseComparison($new, $old)[0]));
} else {
var_dump('Skipped since current PHP version does not have PHP_FLOAT_EPSILON defined');
$this->assertTrue(true);
}
$this->assertEquals(0, count($diff->looseComparison($new, $old)));
$this->assertFalse(isset($diff->looseComparison($new, $old)[0]));
}

/** @test */
Expand Down
136 changes: 135 additions & 1 deletion tests/ArrayDiffEdgeCasesTest.php
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -174,7 +174,6 @@ public function it_handles_nested_array_vs_scalar_transitions()
/** @test */
public function it_handles_very_large_float_precision()
{
$this->markTestSkipped('TODO: fix precision handling');
$diff = new ArrayDiffMultidimensional();

$precision = 1e-15;
Expand All @@ -196,6 +195,141 @@ public function it_handles_very_large_float_precision()
$this->assertTrue(is_array($result));
}

/** @test */
public function it_handles_float_precision_edge_cases()
{
$diff = new ArrayDiffMultidimensional();

// Test NaN values
$new = ['nan_value' => NAN];
$old = ['nan_value' => NAN];
$result = $diff->compare($new, $old, true);
$this->assertEquals([], $result);

// Test infinity values
$new = ['infinity' => INF, 'negative_infinity' => -INF];
$old = ['infinity' => INF, 'negative_infinity' => -INF];
$result = $diff->compare($new, $old, true);
$this->assertEquals([], $result);

// Test infinity vs large numbers
$new = ['inf_vs_large' => INF];
$old = ['inf_vs_large' => defined('PHP_FLOAT_MAX') ? PHP_FLOAT_MAX : 1.7976931348623E+308];
$result = $diff->compare($new, $old, true);
$this->assertEquals(['inf_vs_large' => INF], $result);

// Test negative zero vs positive zero
$new = ['zero' => -0.0];
$old = ['zero' => 0.0];
$result = $diff->compare($new, $old, true);
$this->assertEquals([], $result); // -0.0 === 0.0 in PHP

// Test float epsilon differences
$epsilon = defined('PHP_FLOAT_EPSILON') ? PHP_FLOAT_EPSILON : 2.2204460492503E-16;
$new = ['epsilon_test' => 1.0 + $epsilon];
$old = ['epsilon_test' => 1.0];
$result = $diff->compare($new, $old, true);

// TODO: Depending on PHP version and float handling, this might or might not be considered different
// $this->assertEquals(['epsilon_test' => 1.0 + $epsilon], $result);

// Test float precision limits with very small numbers
$new = ['tiny' => 1e-308]; // Near the smallest normal float
$old = ['tiny' => 1e-309];
$result = $diff->compare($new, $old, true);
$this->assertTrue(is_array($result)); // Should not crash

// Test float precision with scientific notation
$new = ['scientific' => 1.23e10, 'negative_scientific' => -4.56e-7];
$old = ['scientific' => 12300000000.0, 'negative_scientific' => -0.000000456];
$result = $diff->compare($new, $old, true);
$this->assertEquals([], $result); // Should be equal despite different notation

// Test denormalized numbers (subnormal floats)
$new = ['denorm' => 4.9e-324]; // Smallest positive denormalized float
$old = ['denorm' => 0.0];
$result = $diff->compare($new, $old, true);

// TODO: Depending on PHP version and float handling, this might or might not be considered different
// $this->assertEquals(['denorm' => 4.9e-324], $result);
}

/** @test */
public function it_handles_float_string_conversion_edge_cases()
{
$diff = new ArrayDiffMultidimensional();

// Test floats that might lose precision when converted to strings
$problematic_floats = [
'large_precise' => 999999999999999.9,
'small_precise' => 0.000000000000001,
'repeating_decimal' => 1.0 / 3.0, // 0.33333...
'long_decimal' => 1.23456789012345678901234567890,
'scientific_large' => 1.2345e20,
'scientific_small' => 9.8765e-15
];

$new = $problematic_floats;
$old = $problematic_floats; // Same values

$result = $diff->compare($new, $old, true);
$this->assertEquals([], $result);

// Test with slight modifications
$old['large_precise'] = 999999999999999.8;
$old['small_precise'] = 0.000000000000002;

$result = $diff->compare($new, $old, true);
$this->assertArrayHasKey('large_precise', $result);
$this->assertArrayHasKey('small_precise', $result);
}

/** @test */
public function it_handles_float_comparison_in_nested_structures()
{
$this->markTestSkipped('Pending implementation of improved float comparison logic in nested structures.');

$diff = new ArrayDiffMultidimensional();

$new = [
'nested_floats' => [
'level1' => [
'precise' => 1.0000000000000001,
'imprecise' => 1.1,
'infinity' => INF,
'nan' => NAN
],
'calculations' => [
'division' => 1.0 / 3.0,
'multiplication' => 0.1 * 3.0,
'sqrt' => sqrt(2)
]
]
];

$old = [
'nested_floats' => [
'level1' => [
'precise' => 1.0000000000000002,
'imprecise' => 1.1,
'infinity' => INF,
'nan' => NAN
],
'calculations' => [
'division' => 0.33333333333333333,
'multiplication' => 0.30000000000000004,
'sqrt' => 1.4142135623730951
]
]
];

$result = $diff->compare($new, $old, true);

// Should detect differences in precision and NaN comparison
$this->assertArrayHasKey('nested_floats', $result);
$this->assertTrue(is_array($result)); // Should not crash with complex nested float comparisons
}

/** @test */
public function it_handles_empty_arrays_at_different_nesting_levels()
{
Expand Down