Memory Similarity Calculator Skill

Guidance for working with MemorySimilarityCalculator in the lib-electronic-components library.

For metadata-driven similarity architecture, see /similarity-metadata:

• SpecImportance levels (CRITICAL, HIGH, MEDIUM, LOW, OPTIONAL)
• ToleranceRule types (exactMatch, percentageTolerance, minimumRequired, etc.)
• SimilarityProfile contexts (DESIGN_PHASE, REPLACEMENT, COST_OPTIMIZATION, etc.)
• Calculator integration patterns and gotchas

Overview

The MemorySimilarityCalculator compares memory ICs based on:

• Equivalent groups - Cross-manufacturer equivalents
• Memory type - EEPROM, Flash, etc.
• Interface - I2C, SPI
• Capacity - Must match for high similarity
• Voltage range - Operating voltage compatibility

Applicable Types

ComponentType.MEMORY
// Any type starting with "MEMORY_"
// Returns true for null to handle unrecognized memory devices

Similarity Thresholds

HIGH_SIMILARITY = 0.9;   // Equivalent parts
MEDIUM_SIMILARITY = 0.7; // Same type/interface, close specs
LOW_SIMILARITY = 0.3;    // Different capacity or interface

I2C EEPROM Equivalents

calculator.calculateSimilarity("24LC256", "AT24C256", registry);
// Returns >= 0.7 (equivalent I2C EEPROMs)

SPI EEPROM Equivalents

SPI Flash Equivalents

calculator.calculateSimilarity("W25Q32JV", "MX25L3233F", registry);
// Returns >= 0.3 (same capacity SPI Flash)

Interface Rules

I2C and SPI memory have lower similarity due to different interfaces:

calculator.calculateSimilarity("24LC256", "25LC256", registry);
// Returns <= 0.7 (same capacity, different interface)

Capacity Rules

Different capacities return LOW_SIMILARITY:

calculator.calculateSimilarity("W25Q32JV", "W25Q128JV", registry);
// Returns 0.3 (same family, different size)

Package Handling

Package codes don't significantly affect similarity for memory:

• Same memory, different package = HIGH_SIMILARITY (0.9)
• Same memory, compatible package = HIGH_SIMILARITY (0.9)
• Same memory, different package type = ~0.8

Manufacturer Prefixes

Test Examples

// Same I2C EEPROM
calculator.calculateSimilarity("24LC256", "24LC256", registry);
// Returns 1.0

// Cross-manufacturer I2C EEPROM
calculator.calculateSimilarity("24LC256", "AT24C256", registry);
// Returns >= 0.7

// Same Flash, different manufacturer
calculator.calculateSimilarity("W25Q64JV", "MX25L6433F", registry);
// Returns >= 0.3

// Different capacity
calculator.calculateSimilarity("24LC256", "24LC512", registry);
// Returns 0.3

Metadata-Driven Implementation (January 2026)

Status: ✅ Converted (PR #117)

The MemorySimilarityCalculator now uses a metadata-driven approach with spec-based comparison.

Specs Compared

Implementation Pattern

// Short-circuit check for CRITICAL incompatibility
if (!memoryType1.isEmpty() && !memoryType2.isEmpty() && !memoryType1.equals(memoryType2)) {
    return LOW_SIMILARITY;
}
if (!capacity1.isEmpty() && !capacity2.isEmpty() && !capacity1.equals(capacity2)) {
    return LOW_SIMILARITY;
}

// Weighted spec scoring
// memoryType: CRITICAL (1.0 weight)
// capacity: CRITICAL (1.0 weight)
// interface: HIGH (0.7 weight)
// package: LOW (0.2 weight)

Behavior Changes

Why more accurate: Metadata approach prioritizes capacity and type matching, with interface as secondary concern.

Learnings & Quirks

Part Number Patterns

• 24xx = I2C interface, 25xx = SPI interface
• C often indicates CMOS
• Capacity in Kbits: 256 = 32KB, 512 = 64KB, 1024 = 128KB

Revision Suffixes

• JV, FW, JW on Winbond = package/voltage variants
• A, B, C suffixes = revisions (usually compatible)

Voltage Compatibility

• Standard: 2.7V-5.5V
• Low voltage: 1.7V-3.6V (check compatibility)