Class: Edlib::Aligner

Inherits:

Object

• Object
• Edlib::Aligner

Defined in:

lib/edlib.rb,
ext/edlib/edlibext.c

Instance Method Summary

• #additional_equalities ⇒ Object
• #additional_equalities=(equalities) ⇒ Object
• #align(query, target) ⇒ Object
• #config ⇒ Object
• #initialize(k: -1,, mode: 'NW', task: 'DISTANCE', additional_equalities: nil) ⇒ Aligner constructor

  A new instance of Aligner.

• #k ⇒ Object
• #k=(k) ⇒ Object
• #mode ⇒ Object
• #mode=(mode) ⇒ Object
• #task ⇒ Object
• #task=(task) ⇒ Object

Constructor Details

#initialize(k: -1,, mode: 'NW', task: 'DISTANCE', additional_equalities: nil) ⇒ Aligner

Returns a new instance of Aligner.

# File 'lib/edlib.rb', line 5

def initialize(k: -1, mode: 'NW', task: 'DISTANCE', additional_equalities: nil)
  mode = mode.to_s if mode.is_a? Symbol
  task = task.to_s if task.is_a? Symbol
  mode = mode.upcase if mode.is_a? String
  task = task.upcase if task.is_a? String
  initialize_raw(k, mode, task, additional_equalities)
end

Instance Method Details

#additional_equalities ⇒ Object

# File 'ext/edlib/edlibext.c', line 244

static VALUE
aligner_get_additional_equalities(VALUE self)
{
  EdlibAlignConfig *config = get_config(self);
  return get_additional_equalities(config);
}

#additional_equalities=(equalities) ⇒ Object

# File 'ext/edlib/edlibext.c', line 312

static VALUE
aligner_set_additional_equalities(VALUE self, VALUE equalities)
{
  EdlibAlignConfig *config = get_config(self);
  return set_additional_equalities(config, equalities);
}

#align(query, target) ⇒ Object

# File 'ext/edlib/edlibext.c', line 355

static VALUE
aligner_align(VALUE self, VALUE query, VALUE target)
{
  EdlibAlignConfig *config = get_config(self);
  if (!config)
  {
    rb_raise(rb_eRuntimeError, "config is NULL");
  }
  EdlibAlignConfig cfg = edlibNewAlignConfig(
    config->k,
    config->mode,
    config->task,
    config->additionalEqualities,
    config->additionalEqualitiesLength);

  EdlibAlignResult result = edlibAlign(
    StringValueCStr(query),
    RSTRING_LEN(query),
    StringValueCStr(target),
    RSTRING_LEN(target),
    cfg);

  if (result.status != 0)
  {
    rb_raise(rb_eRuntimeError, "edlibAlign failed");
  }

  VALUE edit_distance = INT2NUM(result.editDistance);
  VALUE alphabet_length = INT2NUM(result.alphabetLength);
  VALUE locations = rb_ary_new();
  VALUE alignment = rb_ary_new();
  VALUE cigar;

  int *el = result.endLocations;
  int *sl = result.startLocations;
  for (int i = 0; i < result.numLocations; i++)
  {
    VALUE ary = rb_ary_new();
    if (sl)
    {
      rb_ary_push(ary, INT2NUM(sl[i]));
    }
    else
    {
      rb_ary_push(ary, Qnil);
    }
    if (el)
    {
      rb_ary_push(ary, INT2NUM(el[i]));
    }
    else
    {
      rb_ary_push(ary, Qnil);
    }
    rb_ary_push(locations, ary);
  }

  for (int i = 0; i < result.alignmentLength; i++)
  {
    rb_ary_push(alignment, UINT2NUM(result.alignment[i]));
  }

  char *ccigar = edlibAlignmentToCigar(result.alignment, result.alignmentLength, 1); // EDLIB_CIGAR_EXTENDED
  cigar = rb_str_new2(ccigar);

  VALUE hash = rb_hash_new();
  rb_hash_aset(hash, ID2SYM(rb_intern("edit_distance")), edit_distance);
  rb_hash_aset(hash, ID2SYM(rb_intern("alphabet_length")), alphabet_length);
  rb_hash_aset(hash, ID2SYM(rb_intern("locations")), locations);
  rb_hash_aset(hash, ID2SYM(rb_intern("alignment")), alignment);
  rb_hash_aset(hash, ID2SYM(rb_intern("cigar")), cigar);

  edlibFreeAlignResult(result);

  return hash;
}

#config ⇒ Object

# File 'ext/edlib/edlibext.c', line 319

static VALUE
aligner_config_hash(VALUE self)
{
  EdlibAlignConfig *config = get_config(self);

  VALUE hash = rb_hash_new();

  rb_hash_aset(hash, ID2SYM(rb_intern("k")), get_k(config));
  rb_hash_aset(hash, ID2SYM(rb_intern("mode")), get_mode(config));
  rb_hash_aset(hash, ID2SYM(rb_intern("task")), get_task(config));
  rb_hash_aset(hash, ID2SYM(rb_intern("additional_equalities")), get_additional_equalities(config));

  return hash;
}

#k ⇒ Object

# File 'ext/edlib/edlibext.c', line 62

static VALUE
aligner_get_k(VALUE self)
{
  EdlibAlignConfig *config = get_config(self);
  return get_k(config);
}

#k=(k) ⇒ Object

# File 'ext/edlib/edlibext.c', line 76

static VALUE
aligner_set_k(VALUE self, VALUE k)
{
  EdlibAlignConfig *config = get_config(self);
  return set_k(config, k);
}

#mode ⇒ Object

# File 'ext/edlib/edlibext.c', line 99

static VALUE
aligner_get_mode(VALUE self)
{
  EdlibAlignConfig *config = get_config(self);
  return get_mode(config);
}

#mode=(mode) ⇒ Object

# File 'ext/edlib/edlibext.c', line 148

static VALUE
aligner_set_mode(VALUE self, VALUE mode)
{
  EdlibAlignConfig *config = get_config(self);
  return set_mode(config, mode);
}

#task ⇒ Object

# File 'ext/edlib/edlibext.c', line 171

static VALUE
aligner_get_task(VALUE self)
{
  EdlibAlignConfig *config = get_config(self);
  return get_task(config);
}

#task=(task) ⇒ Object

# File 'ext/edlib/edlibext.c', line 220

static VALUE
aligner_set_task(VALUE self, VALUE task)
{
  EdlibAlignConfig *config = get_config(self);
  return set_task(config, task);
}