Skip to content
Skills Library
Programming · Analysis

interval-difference-analyzer

/interval-difference-analyzer

Analyze differences in program intervals between two versions of a program (old and new) to identify added, removed, or modified intervals. Use when comparing program versions, analyzing variable ranges, detecting behavioral changes in numeric computations, validating refactorings, or assessing migration impacts. Supports optional test suite integration to validate interval changes. Generates comprehensive reports highlighting intervals requiring further testing or verification.

Repository
Skills-4-SE ↗
Licence
Apache-2.0
Last repository change
21.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
5
Scripts
2
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.08.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/compare_intervals.py, scripts/interval_analyzer.py

What it does and when to use it

Analyze differences in program intervals between two versions of a program (old and new) to identify added, removed, or modified intervals. Use when comparing program versions, analyzing variable ranges, detecting behavioral changes in numeric computations, validating refactorings, or assessing migration impacts. Supports optional test suite integration to validate interval changes. Generates comprehensive reports highlighting intervals requiring further testing or verification.

Original author description

Analyze differences in program intervals between two versions of a program (old and new) to identify added, removed, or modified intervals. Use when comparing program versions, analyzing variable ranges, detecting behavioral changes in numeric computations, validating refactorings, or assessing migration impacts. Supports optional test suite integration to validate interval changes. Generates comprehensive reports highlighting intervals requiring further testing or verification.

How it works

  1. Overview
  2. Core Workflow
  3. What Are Program Intervals?
  4. Interval Extraction Methods
  5. Interval Comparison
  6. Behavioral Change Detection
  7. Testing Recommendations
  8. Report Format
  9. Integration with Test Suites
  10. Best Practices
Original SKILL.md headings · 262 lines, 726 words
SKILL.md preview
---
name: interval-difference-analyzer
description: Analyze differences in program intervals between two versions of a program (old and new) to identify added, removed, or modified intervals. Use when comparing program versions, analyzing variable ranges, detecting behavioral changes in numeric computations, validating refactorings, or assessing migration impacts. Supports optional test suite integration to validate interval changes. Generates comprehensive reports highlighting intervals requiring further testing or verification.
---

# Interval Difference Analyzer

## Overview

Analyze differences in program intervals (variable value ranges) between two versions of a program to detect behavioral changes, identify potential bugs, and guide testing efforts.

## Core Workflow

### 1. Setup Program Versions

Prepare both program versions for analysis:

```bash
OLD_VERSION=/path/to/old/program
NEW_VERSION=/path/to/new/program
TEST_SUITE=/path/to/tests  # Optional
```

### 2. Extract Intervals

Extract interval information from both versions:

```bash
python scripts/interval_analyzer.py \
    --program $OLD_VERSION \
    --output old_intervals.json

python scripts/interval_analyzer.py \
    --program $NEW_VERSION \
    --output new_intervals.json
```

### 3. Compare Intervals

Compare intervals and identify differences:

```bash
python scripts/compare_intervals.py \
    --old old_intervals.json \
    --new new_intervals.json \
    --output interval_diff_report.json
```

### 4. Review Report

Examine the generated report for:
- Added intervals (new variables or wider ranges)
- Removed intervals (deleted variables or narrower ranges)
- Modified intervals (changed bounds)
- Behavioral implications
- Testing recommendations

## What Are Program Intervals?

**Program intervals** represent the possible ranges of values that variables can take during program execution.

**Example**:
```python
def calculate_discount(price, discount_rate):
    # Intervals:
    # price: [0, 10000]
    # discount_rate: [0.0, 1.0]
    # discount: [0, 10000]
    discount = price * discount_rate
    return discount
```

**Why intervals matter**:
- Detect overflow/underflow risks
- Identify boundary condition changes
- Validate numeric computation correctness
- Guide test case generation

## Interval Extraction Methods

### Method 1: Static Analysis

Analyze code to infer possible value ranges without execution.

### Method 2: Dynamic Analysis

Execute program with test inputs and observe actual ranges.

### Method 3: Abstract Interpretation

Use abstract domains to compute sound interval approximations.

## Interval Comparison

### Identifying Added Intervals

**Pattern**: New variables or wider ranges in new version

**Implications**:
- New computation paths
- Potential new bugs
- Requires new tests

### Identifying Removed Intervals

**Pattern**: Deleted variables or narrower ranges in new version

**Implications**:
- Simplified computation
- Reduced intermediate state
- May affect debugging

### Identifying Modified Intervals

**Pattern**: Changed bounds for existing variables

**Example**:
```python
# Old version: age: [0, 120]
# New version: age: [0, 150]  # Widened!
```

**Implications**:
- Relaxed constraints
- May accept invalid inputs
- Requires validation testing

## Behavioral Change Detection

### Overflow/Underflow Detection

Check if new intervals exceed type bounds.

**Example**:
```python
# Old: result: [0, 1000000] ✓ Safe (int32)
# New: result: [0, 10000000000] ✗ Overflow risk!
```

### Precision Loss Detection

Check if new intervals lose precision.

**Example**:
```python
# Old: result: [0.0, 100.0] (float)
# New: result: [0, 100] (int) - precision loss!
```

### Boundary Condition Changes

Check if interval boundaries change critically.

**Example**:
```python
# Old: index: [0, 99]
# New: index: [-1, 99]  # Negative index possible!
```

## Testing Recommendations

### Priority Levels

**Critical**: Test immediately
- Overflow/underflow risks
- Negative indices
- Division by zero
- Type mismatches

**High**: Test soon
- Widened intervals
- Boundary changes
- Precision loss

**Medium**: Test when convenient
- Narrowed intervals (safer)
- Removed intermediate variables

**Low**: Optional testing
- Cosmetic changes
- Unchanged intervals

### Test Case Generation

Generate test cases targeting interval boundaries:

```python
# Interval: x: [0, 100]
test_cases = [0, 1, 50, 99, 100]

# For modified interval: [0, 100] → [0, 150]
additional_tests = [101, 125, 149, 150]
```

## Report Format

The analyzer generates a comprehensive JSON report:

```json
{
  "summary": {
    "total_intervals_old": 45,
    "total_intervals_new": 48,
    "added_intervals": 5,
    "removed_intervals": 2,
    "modified_intervals": 8
  },
  "differences": [
    {
      "type": "modified",
      "variable": "age",
      "old_interval": "[0, 120]",
      "new_interval": "[0, 150]",
      "severity": "high",
      "implications": ["Accepts wider range"],
      "testing_priority": "high",
      "suggested_tests": [121, 135, 149, 150]
    }
  ],
  "recommendations": [
    "Test modified intervals with boundary values",
    "Verify no overflow in calculations"
  ]
}
```

## Integration with Test Suites

### Validate Intervals with Tests

Run existing tests and verify intervals:

```bash
python scripts/validate_intervals.py \
    --program $NEW_VERSION \
    --intervals new_intervals.json \
    --test-suite $TEST_SUITE
```

### Generate Tests from Intervals

Automatically generate tests for interval boundaries:

```bash
python scripts/generate_interval_tests.py \
    --intervals interval_diff_report.json \
    --output generated_tests.py
```

## Best Practices

1. **Use both static and dynamic analysis**: Combine for better coverage
2. **Focus on critical intervals**: Prioritize safety-critical variables
3. **Test boundary values**: Always test interval bounds
4. **Document intentional changes**: Mark expected interval modifications
5. **Automate analysis**: Integrate into CI/CD pipeline

## Resources

- **[references/interval_analysis.md](references/interval_analysis.md)**: Detailed interval analysis techniques
- **[references/abstract_interpretation.md](references/abstract_interpretation.md)**: Abstract interpretation theory
- **scripts/interval_analyzer.py**: Main interval extraction tool
- **scripts/compare_intervals.py**: Interval comparison engine
- **scripts/validate_intervals.py**: Test suite validation
- **scripts/generate_interval_tests.py**: Test case generator
Files in this package (5)
  • SKILL.md 6 KB
  • references/abstract_interpretation.md 8 KB
  • references/interval_analysis.md 8 KB
  • scripts/compare_intervals.py 13 KB
  • scripts/interval_analyzer.py 8 KB

Versions

The database has no other skills named interval-difference-analyzer.

Database snapshot: 13.11.2026 · package version 0a33dd12c9e9 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100interval-guided-regression-test-update
    Automatically updates regression tests based on interval analysis to maintain coverage of key program intervals. Use when code changes affect value ranges, conditionals, or control flow, and existing tests need updating to maintain interval coverage. Analyzes interval…
  • 100multi-version-behavior-comparator
    Compare behavior across multiple versions of programs or repositories. Use when you need to analyze how functionality changes between versions, identify regressions, compare outputs and exceptions, or validate upgrades. The skill compares execution behavior, test results,…
  • 100document-changes
    Generate a markdown report documenting codebase changes from the current session — files added, modified, deleted, and a summary of what was done. Use when asked to "document changes", "generate change report", "save changes report", "what did I change", "session report",…
  • 100document-changes
    Generate a markdown report documenting codebase changes from the current session — files added, modified, deleted, and a summary of what was done. Use when asked to "document changes", "generate change report", "save changes report", "what did I change", "session report",…
  • 100gc-log-analyzer
    Analyze gc log analyzer operations. Auto-activating skill for Performance Testing. Triggers on: gc log analyzer, gc log analyzer Part of the Performance Testing skill category. Use when analyzing or auditing gc log analyzer. Trigger with phrases like "gc log analyzer", "gc…
  • 100coverage-report-analyzer
    Analyze coverage report analyzer operations. Auto-activating skill for Test Automation. Triggers on: coverage report analyzer, coverage report analyzer Part of the Test Automation skill category. Use when analyzing or auditing coverage report analyzer. Trigger with phrases like…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.