algomate 0.1.0

Professional algorithm selection companion with intelligent strategy selection, built-in benchmarking, and performance optimization. Features Clean Architecture, comprehensive error handling, and prod [...]

example/algomate_example.dart

import 'package:algomate/algomate.dart';

/// Comprehensive example demonstrating basic usage of AlgoMate.
void main() {
  print('🤖 AlgoMate - Algorithm Selection Companion');
  print('==========================================\n');

  // Create a selector with development settings (includes logging)
  final selector = AlgoSelectorFacade.development();

  // Example 1: Basic sorting with automatic algorithm selection
  basicSortingExample(selector);

  print('\n');

  // Example 2: Algorithm selection based on different dataset sizes
  datasetSizeExample(selector);

  print('\n');

  // Example 3: Memory-constrained environments
  memoryConstraintExample(selector);

  print('\n');

  // Example 4: Search operations
  searchExample(selector);

  print('\n');

  // Example 5: Custom strategy registration
  customStrategyExample(selector);

  print('\n');

  // Example 6: Performance analysis
  performanceExample(selector);
}

void basicSortingExample(AlgoSelectorFacade selector) {
  print('📊 1. Basic Sorting Examples');
  print('----------------------------');

  final data = [64, 34, 25, 12, 22, 11, 90, 5];
  print('Original data: $data');

  // AlgoMate automatically chooses the best algorithm
  final result = selector.sort(
    input: data,
    hint: SelectorHint(n: data.length),
  );

  result.fold((success) {
    print('✅ Sorted: ${success.output}');
    print('   Algorithm used: ${success.selectedStrategy.name}');
    print('   Time complexity: ${success.selectedStrategy.timeComplexity}');
    print('   Space complexity: ${success.selectedStrategy.spaceComplexity}');
  }, (failure) => print('❌ Sorting failed: $failure'),);
}

void datasetSizeExample(AlgoSelectorFacade selector) {
  print('📏 2. Dataset Size-Based Selection');
  print('----------------------------------');

  // Small dataset (< 50 elements) - should prefer insertion sort
  final smallData = List.generate(10, (i) => 10 - i);
  print('Small dataset (${smallData.length} elements):');

  var result = selector.sort(input: smallData, hint: SelectorHint.small());
  result.fold((success) {
    print('   → Selected: ${success.selectedStrategy.name}');
    print('   → Reason: Optimal for small datasets');
  }, (failure) => print('   ❌ Failed: $failure'),);

  // Medium dataset (50-1000 elements) - may choose binary insertion
  final mediumData = List.generate(100, (i) => 100 - i);
  print('\nMedium dataset (${mediumData.length} elements):');

  result = selector.sort(
    input: mediumData,
    hint: SelectorHint(n: mediumData.length),
  );
  result.fold((success) {
    print('   → Selected: ${success.selectedStrategy.name}');
    print('   → Complexity: ${success.selectedStrategy.timeComplexity}');
  }, (failure) => print('   ❌ Failed: $failure'),);

  // Large dataset (> 1000 elements) - should prefer merge sort
  final largeData = List.generate(2000, (i) => 2000 - i);
  print('\nLarge dataset (${largeData.length} elements):');

  result = selector.sort(input: largeData, hint: SelectorHint.large());
  result.fold((success) {
    print('   → Selected: ${success.selectedStrategy.name}');
    print('   → First 10: ${success.output.take(10).toList()}');
    print('   → Last 10: ${success.output.skip(success.output.length - 10).toList()}');
  }, (failure) => print('   ❌ Failed: $failure'),);
}

void memoryConstraintExample(AlgoSelectorFacade selector) {
  print('💾 3. Memory Constraint Examples');
  print('--------------------------------');

  final data = List.generate(500, (i) => 500 - i);

  // Low memory constraint - should prefer in-place algorithms
  print('Low memory environment:');
  var result = selector.sort(
    input: List.from(data),
    hint: SelectorHint.lowMemory(n: data.length),
  );

  result.fold((success) {
    print('   → Selected: ${success.selectedStrategy.name}');
    print('   → Space complexity: ${success.selectedStrategy.spaceComplexity}');
  }, (failure) => print('   ❌ Failed: $failure'),);

  // Regular memory - can choose best time complexity
  print('\nRegular memory environment:');
  result = selector.sort(
    input: List.from(data),
    hint: SelectorHint(n: data.length),
  );

  result.fold((success) {
    print('   → Selected: ${success.selectedStrategy.name}');
    print('   → Time complexity: ${success.selectedStrategy.timeComplexity}');
  }, (failure) => print('   ❌ Failed: $failure'),);
}

void searchExample(AlgoSelectorFacade selector) {
  print('🔍 4. Search Operations');
  print('-----------------------');

  final sortedData = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
  final unsortedData = [64, 34, 25, 12, 22, 11, 90];

  // Binary search on sorted data
  print('Binary search on sorted data:');
  var result = selector.search(input: sortedData, target: 7, hint: const SelectorHint(sorted: true));

  result.fold((success) {
    if (success.output != null) {
      print('   → Found 7 at index: ${success.output}');
    } else {
      print('   → 7 not found in data');
    }
    print('   → Algorithm: ${success.selectedStrategy.name}');
    print('   → Complexity: ${success.selectedStrategy.timeComplexity}');
  }, (failure) => print('   ❌ Search failed: $failure'),);

  // Linear search on unsorted data
  print('\nLinear search on unsorted data:');
  result = selector.search(input: unsortedData, target: 25, hint: const SelectorHint(sorted: false));

  result.fold((success) {
    if (success.output != null) {
      print('   → Found 25 at index: ${success.output}');
    } else {
      print('   → 25 not found in data');
    }
    print('   → Algorithm: ${success.selectedStrategy.name}');
  }, (failure) => print('   ❌ Search failed: $failure'),);
}

void customStrategyExample(AlgoSelectorFacade selector) {
  print('🛠️ 5. Custom Strategy Registration');
  print('-----------------------------------');

  // Create a custom bubble sort strategy
  final customStrategy = _CustomBubbleSortStrategy();
  final signature = StrategySignature.sort(inputType: List<int>);

  // Register the custom strategy
  final registerResult = selector.register<List<int>, List<int>>(strategy: customStrategy, signature: signature, allowReplace: true);

  registerResult.fold((success) {
    print('✅ Custom bubble sort registered successfully');

    // Use the custom strategy by providing conditions where it's optimal
    final data = [5, 2, 8, 1, 9]; // Very small dataset where bubble sort is acceptable
    final result = selector.sort(
      input: data,
      hint: SelectorHint(n: data.length),
    );

    result.fold((success) {
      print('   → Result: ${success.output}');
      print('   → Strategy: ${success.selectedStrategy.name}');
    }, (failure) => print('   ❌ Custom sort failed: $failure'),);
  }, (failure) => print('❌ Failed to register custom strategy: $failure'),);
}

void performanceExample(AlgoSelectorFacade selector) {
  print('⚡ 6. Performance Analysis');
  print('-------------------------');

  // Test different dataset sizes and compare performance
  final testSizes = [10, 50, 100, 500];

  for (final size in testSizes) {
    final data = List.generate(size, (i) => size - i); // Reverse sorted (worst case)

    final result = selector.sort(
      input: data,
      hint: SelectorHint(n: size),
    );

    result.fold((success) {
      print('Size $size:');
      print('   → Algorithm: ${success.selectedStrategy.name}');
      print('   → Complexity: ${success.selectedStrategy.timeComplexity}');
    }, (failure) => print('Size $size: ❌ Failed: $failure'),);
  }

  // Show algorithm selection statistics
  print('\n📈 Selection Statistics:');
  final stats = selector.getStats();
  print('   → Total strategies: ${stats.totalStrategies}');
  print('   → Total signatures: ${selector.signatures.length}');

  print('\n📋 Available Signatures:');
  for (final signature in selector.signatures) {
    print('   • $signature');
  }
}

/// Custom bubble sort implementation for demonstration
class _CustomBubbleSortStrategy extends Strategy<List<int>, List<int>> {
  @override
  AlgoMetadata get meta =>
      const AlgoMetadata(name: 'custom_bubble_sort', timeComplexity: TimeComplexity.oN2, spaceComplexity: TimeComplexity.o1, requiresSorted: false);

  @override
  bool canApply(List<int> input, SelectorHint hint) {
    // Only use bubble sort for very small datasets where simplicity matters
    final n = hint.n ?? input.length;
    return n <= 5; // Very restrictive - only for tiny datasets
  }

  @override
  List<int> execute(List<int> input) {
    final result = List<int>.from(input);
    final n = result.length;

    for (var i = 0; i < n - 1; i++) {
      for (var j = 0; j < n - i - 1; j++) {
        if (result[j] > result[j + 1]) {
          // Swap elements
          final temp = result[j];
          result[j] = result[j + 1];
          result[j + 1] = temp;
        }
      }
    }

    return result;
  }
}