stride-align 0.6.0

data/lib/stride_align/alignment_path.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module StrideAlign
+  class AlignmentPath
+    ATTRIBUTES = %i[
+      score query_start query_end target_start target_end operations cigar
+      matches mismatches insertions deletions aligned_length
+    ].freeze
+
+    attr_reader(*ATTRIBUTES)
+
+    def initialize(score: 0, query_start: 0, query_end: 0,
+                   target_start: 0, target_end: 0,
+                   operations: "", cigar: "", matches: 0,
+                   mismatches: 0, insertions: 0, deletions: 0,
+                   aligned_length: nil)
+      @score = score
+      @query_start = query_start
+      @query_end = query_end
+      @target_start = target_start
+      @target_end = target_end
+      @operations = operations
+      @cigar = cigar
+      @matches = matches
+      @mismatches = mismatches
+      @insertions = insertions
+      @deletions = deletions
+      @aligned_length = aligned_length.nil? ? operations.length : aligned_length
+    end
+
+    def to_h
+      ATTRIBUTES.each_with_object({}) { |name, output| output[name] = public_send(name) }
+    end
+
+    def inspect
+      "#<#{self.class} score=#{score} query=[#{query_start},#{query_end}) " \
+        "target=[#{target_start},#{target_end}) cigar=#{cigar.inspect}>"
+    end
+  end
+
+  class AlignmentResult < AlignmentPath
+    attr_reader :aligned_query, :aligned_target
+
+    def initialize(aligned_query: "", aligned_target: "", **attributes)
+      super(**attributes)
+      @aligned_query = aligned_query
+      @aligned_target = aligned_target
+    end
+
+    def aligned
+      { query: aligned_query, target: aligned_target }
+    end
+
+    def to_h
+      super.merge(aligned: aligned)
+    end
+
+    def to_path
+      attributes = AlignmentPath::ATTRIBUTES.each_with_object({}) do |name, output|
+        output[name] = public_send(name)
+      end
+      AlignmentPath.new(**attributes)
+    end
+  end
+
+  class Scores
+    attr_reader :query, :variant
+
+    def initialize(query, variant: :smith_waterman, match_score: 2,
+                   mismatch_score: -1, gap_score: -1,
+                   gap_open_score: nil, gap_extend_score: nil, width: nil)
+      @query = StrideAlign.__send__(:scalar_query, query)
+      @variant = variant.to_sym
+      @variant = :smith_waterman_farrar if @variant == :farrar
+      @compare_method = case @variant
+                        when :smith_waterman then :smith_waterman_scores
+                        when :needleman_wunsch then :needleman_wunsch_scores
+                        when :smith_waterman_farrar then :smith_waterman_farrar_scores
+                        else
+                          raise ArgumentError, "unknown score variant: #{variant}"
+                        end
+      @options = {
+        match_score: match_score, mismatch_score: mismatch_score,
+        gap_score: gap_score, gap_open_score: gap_open_score,
+        gap_extend_score: gap_extend_score, width: width
+      }
+    end
+
+    def compare(targets)
+      StrideAlign.public_send(@compare_method, @query, targets, **@options)
+    end
+  end
+
+  class << self
+    def smith_waterman_path(query, target, match_score: 2,
+                            mismatch_score: -1, gap_score: -1,
+                            gap_open_score: nil, gap_extend_score: nil,
+                            width: nil, matrix: nil)
+      alignment_path(
+        query, target, true,
+        match_score: match_score, mismatch_score: mismatch_score,
+        gap_score: gap_score, gap_open_score: gap_open_score,
+        gap_extend_score: gap_extend_score, width: width, matrix: matrix
+      )
+    end
+
+    def smith_waterman_path_info(*args, **kwargs)
+      smith_waterman_path(*args, **kwargs).to_path
+    end
+
+    def needleman_wunsch_path(query, target, match_score: 2,
+                              mismatch_score: -1, gap_score: -1,
+                              gap_open_score: nil, gap_extend_score: nil,
+                              width: nil, matrix: nil)
+      alignment_path(
+        query, target, false,
+        match_score: match_score, mismatch_score: mismatch_score,
+        gap_score: gap_score, gap_open_score: gap_open_score,
+        gap_extend_score: gap_extend_score, width: width, matrix: matrix
+      )
+    end
+
+    def needleman_wunsch_path_info(*args, **kwargs)
+      needleman_wunsch_path(*args, **kwargs).to_path
+    end
+
+    def smith_waterman_cigar(*args, **kwargs)
+      smith_waterman_path_info(*args, **kwargs).cigar
+    end
+    alias smith_waterman_trace_cigar smith_waterman_cigar
+    alias smith_waterman_trade_cigar smith_waterman_cigar
+
+    def needleman_wunsch_cigar(*args, **kwargs)
+      needleman_wunsch_path_info(*args, **kwargs).cigar
+    end
+    alias needleman_wunsch_trace_cigar needleman_wunsch_cigar
+    alias needleman_wunsch_trade_cigar needleman_wunsch_cigar
+
+    private
+
+    def validate_width(width)
+      return if width.nil? || [0, 8, 16, 32, 64].include?(width)
+
+      raise ArgumentError, "width must be nil, 0, 8, 16, 32, or 64"
+    end
+
+    def resolve_gaps(gap_score, gap_open_score, gap_extend_score)
+      open_score = gap_open_score.nil? ? gap_score : gap_open_score
+      extend_score = gap_extend_score.nil? ? open_score : gap_extend_score
+      [open_score, extend_score]
+    end
+
+    def materialize_path(path, query, target)
+      query_points = query.each_char.to_a
+      target_points = target.each_char.to_a
+      query_index = path.query_start
+      target_index = path.target_start
+      aligned_query = []
+      aligned_target = []
+      path.operations.each_char do |operation|
+        if operation == "=" || operation == "X"
+          aligned_query << query_points[query_index]
+          aligned_target << target_points[target_index]
+          query_index += 1
+          target_index += 1
+        elsif operation == "D"
+          aligned_query << query_points[query_index]
+          aligned_target << "-"
+          query_index += 1
+        else
+          aligned_query << "-"
+          aligned_target << target_points[target_index]
+          target_index += 1
+        end
+      end
+      AlignmentResult.new(
+        **path.to_h,
+        aligned_query: aligned_query.join,
+        aligned_target: aligned_target.join
+      )
+    end
+
+    def alignment_path(query, target, local, match_score:, mismatch_score:,
+                       gap_score:, gap_open_score:, gap_extend_score:,
+                       width:, matrix:)
+      validate_width(width)
+      query = scalar_query(query)
+      target = scalar_query(target)
+      open_score, extend_score = resolve_gaps(
+        gap_score, gap_open_score, gap_extend_score
+      )
+      if matrix
+        if match_score != 2 || mismatch_score != -1 || !width.nil?
+          raise ArgumentError,
+                "match_score, mismatch_score, and width cannot be used with matrix"
+        end
+        path = matrix_alignment(
+          query, target, matrix, local,
+          gap_score: gap_score, gap_open_score: gap_open_score,
+          gap_extend_score: gap_extend_score, traceback: true
+        )
+        return materialize_path(path, query, target)
+      end
+
+      attributes = __primary_backend.alignment_path(
+        query, target, local, match_score, mismatch_score,
+        open_score, extend_score
+      )
+      aligned = attributes.delete(:aligned)
+      AlignmentResult.new(
+        **attributes,
+        aligned_query: aligned.fetch(:query),
+        aligned_target: aligned.fetch(:target)
+      )
+    end
+  end
+end

data/lib/stride_align/backend.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module StrideAlign
+  module BackendKind
+    GENERIC = "generic"
+    SWAR = "swar"
+    X86_SSE41 = "sse41"
+    X86_AVX2 = "avx2"
+    X86_AVX512BWVL = "avx512bwvl"
+    X86_AVX10_256 = "avx10_256"
+    X86_AVX10_512 = "avx10_512"
+    LINUX_AARCH64_NEON = "neon"
+    LINUX_AARCH64_SVE = "sve"
+    LINUX_AARCH64_SVE2 = "sve2"
+    MACOS_ARM64_NEON = "neon"
+    LINUX_LOONGARCH64_LSX = "lsx"
+    LINUX_LOONGARCH64_LASX = "lasx"
+    LINUX_POWERPC64_VSX = "vsx"
+    LINUX_RISCV64_RVV = "rvv"
+  end
+
+  BackendRecord = Struct.new(:kind, :name, :compiled, :available, keyword_init: true)
+
+  class << self
+    def stride_backend
+      @backend_name
+    end
+
+    def stride_available_backends
+      __available_backend_names.dup
+    end
+
+    def available_backends
+      stride_available_backends.map do |name|
+        BackendRecord.new(kind: name, name: name, compiled: true, available: true)
+      end
+    end
+
+    def backend_is_available(kind)
+      __available_backend_names.include?(kind.to_s)
+    end
+
+    def detect_best_backend
+      stride_backend
+    end
+  end
+end