bioseqalign 0.0.1

data/ext/bioseqalign/PairwiseAlign.cpp

@@ -0,0 +1,33 @@
+#include "PairwiseAlign.hpp"
+
+PairwiseAlign::PairwiseAlign() {}
+
+PairwiseAlign::PairwiseAlign(std::string s1, std::string s2) {
+  seq1 = s1;
+  seq2 = s2;  
+  score = -10000;
+  matchScore = 1;
+  mismatchScore = -1;
+  indelScore = -1;
+}
+
+// unable to properly figure out how to overload constructor when using RICE
+// PairwiseAlign::PairwiseAlign(std::string s1, std::string s2, int matchS, int mismatchS, int indelS) {
+//   seq1 = s1;
+//   seq2 = s2;  
+//   score = -10000;
+//   matchScore = matchS;
+//   mismatchScore = mismatchS;
+//   indelScore = indelS;
+// }
+
+/**
+ * given an alignment matrix string, split into two, and put in ruby array
+ */
+Rice::Array PairwiseAlign::getArrayFromAlignStr(std::string alignMat) {
+  Rice::Array tmp;
+  int halfLen = alignMat.size()/2;
+  tmp.push(alignMat.substr(0, halfLen));
+  tmp.push(alignMat.substr(halfLen, halfLen));
+  return tmp;
+}

data/ext/bioseqalign/PairwiseAlign.cpp~

@@ -0,0 +1,23 @@
+#include "PairwiseAlign.hpp"
+
+PairwiseAlign::PairwiseAlign() {}
+
+PairwiseAlign::PairwiseAlign(std::string s1, std::string s2) {
+  seq1 = s1;
+  seq2 = s2;  
+  score = -10000;
+  matchScore = 1;
+  mismatchScore = -1;
+  indelScore = -1;
+}
+
+// unable to properly figure out how to overload constructor when using RICE
+// PairwiseAlign::PairwiseAlign(std::string s1, std::string s2, int matchS, int mismatchS, int indelS) {
+//   seq1 = s1;
+//   seq2 = s2;  
+//   score = -10000;
+//   matchScore = matchS;
+//   mismatchScore = mismatchS;
+//   indelScore = indelS;
+// }
+

data/ext/bioseqalign/PairwiseAlign.hpp

@@ -0,0 +1,54 @@
+#ifndef PAIRWISE_ALIGN_HPP
+#define PAIRWISE_ALIGN_HPP
+
+#include <iostream>
+#include <string>
+#include <seqan/align.h>
+
+#include "rice/String.hpp"
+#include "rice/Array.hpp"
+
+using namespace seqan;
+
+typedef String<char> TSequence;                 // sequence type
+typedef StringSet<TSequence> TStringSet;       // container for strings
+typedef StringSet<TSequence, Dependent<> > TDepStringSet;   // dependent string set
+typedef Graph<Alignment<TDepStringSet> > TAlignGraph;   // alignment graph
+
+typedef Align<TSequence,ArrayGaps> TAlign;
+typedef Row<TAlign>::Type TRow;
+
+class PairwiseAlign {
+protected:
+  std::string seq1;
+  std::string seq2;
+  int score;
+  TAlignGraph alignG;
+  int matchScore;
+  int mismatchScore;
+  int indelScore;
+  // return a ruby array of the alignment matrix string
+  Rice::Array getArrayFromAlignStr(std::string alignMat);
+  
+public:
+  PairwiseAlign();
+  PairwiseAlign(std::string s1, std::string s2);
+  //PairwiseAlign(std::string s1, std::string s2, int matchS, int mismatchS, int indelS);
+  virtual ~PairwiseAlign() {}
+  
+  virtual void run() {}
+  int getAlignScore() { return score; }
+  //virtual std::string getAlignment() { return ""; }
+  virtual Rice::Array getAlignment() { Rice::Array tmp; return tmp; }
+  
+  void setMatchScore(int mS) { matchScore = mS; }
+  void setMismatchScore(int mS) { mismatchScore = mS; }
+  void setIndelScore(int idS) { indelScore = idS; }
+
+  std::string getSeq1() { return seq1; }
+  std::string getSeq2() { return seq2; }
+  
+};
+
+
+#endif

data/ext/bioseqalign/PairwiseAlign.hpp~

@@ -0,0 +1,54 @@
+#ifndef PAIRWISE_ALIGN_HPP
+#define PAIRWISE_ALIGN_HPP
+
+#include <iostream>
+#include <string>
+#include <seqan/align.h>
+
+#include "rice/String.hpp"
+#include "rice/Array.hpp"
+
+using namespace seqan;
+
+typedef String<char> TSequence;                 // sequence type
+typedef StringSet<TSequence> TStringSet;       // container for strings
+typedef StringSet<TSequence, Dependent<> > TDepStringSet;   // dependent string set
+typedef Graph<Alignment<TDepStringSet> > TAlignGraph;   // alignment graph
+
+typedef Align<TSequence,ArrayGaps> TAlign;
+typedef Row<TAlign>::Type TRow;
+
+class PairwiseAlign {
+protected:
+  std::string seq1;
+  std::string seq2;
+  int score;
+  TAlignGraph alignG;
+  int matchScore;
+  int mismatchScore;
+  int indelScore;
+  // return a ruby array of the alignment matrix string
+  Rice::Array getArrayFromAlignStr(std::string alignMat);
+  
+public:
+  PairwiseAlign();
+  PairwiseAlign(std::string s1, std::string s2);
+  //PairwiseAlign(std::string s1, std::string s2, int matchS, int mismatchS, int indelS);
+  virtual ~PairwiseAlign() {}
+  
+  virtual void run() {}
+  int getAlignScore() { return score; }
+  //virtual std::string getAlignment() { return ""; }
+  virtual Rice::Array getAlignment() { Rice::Array tmp; return tmp; }
+  
+  void setMatchScore(int mS) { matchScore = mS; }
+  void setMismatchScore(int mS) { mismatchScore = mS; }
+  void setIndelScore(int idS) { indelScore = idS; }
+
+  std::string getSeq1() { return seq1; }
+  std::string getSeq2() { return seq2; }
+  
+};
+
+
+#endif

data/ext/bioseqalign/PrefixSuffixAlign.cpp

@@ -0,0 +1,52 @@
+#include "PrefixSuffixAlign.hpp"
+
+PrefixSuffixAlign::PrefixSuffixAlign() {}
+
+PrefixSuffixAlign::PrefixSuffixAlign(std::string s1, std::string s2) : PairwiseAlign(s1, s2) { }
+
+//std::string PrefixSuffixAlign::getAlignment() {
+//Rice::Array PrefixSuffixAlign::getAlignmentArray() {
+Rice::Array PrefixSuffixAlign::getAlignment() {
+  TSequence tseq1 = seq1;
+  TSequence tseq2 = seq2;
+
+  TStringSet sequences;
+  appendValue(sequences,tseq1);
+  appendValue(sequences,tseq2);
+
+  TAlignGraph alignG(sequences);
+  
+  // don't penalize gaps on begin/end of seq2
+  globalAlignment(alignG, Score<int,Simple>(matchScore,mismatchScore,indelScore), AlignConfig<false, true, false, true>(), NeedlemanWunsch());
+
+ 
+  std::string mat;
+  convertAlignment(alignG, mat);
+  //std::cout<<alignG<<std::endl;
+  //std::cout<<mat<<std::endl;
+  return getArrayFromAlignStr(mat);
+  /*  
+  Rice::Array tmp;
+  int halfLen = mat.size()/2;
+  tmp.push(mat.substr(0, halfLen));
+  tmp.push(mat.substr(halfLen+1, halfLen));
+  return tmp;
+  */
+  //return mat;
+}
+
+
+void PrefixSuffixAlign::run() {
+  TSequence tseq1 = seq1;
+  TSequence tseq2 = seq2;
+
+  TStringSet sequences;
+  appendValue(sequences,tseq1);
+  appendValue(sequences,tseq2);
+
+  TAlignGraph alignG(sequences);
+  
+  // don't penalize gaps on begin/end of seq2
+  score = globalAlignment(alignG, Score<int,Simple>(matchScore,mismatchScore,indelScore), AlignConfig<false, true, false, true>(), NeedlemanWunsch());
+  
+}

data/ext/bioseqalign/PrefixSuffixAlign.cpp~

@@ -0,0 +1,42 @@
+#include "PrefixSuffixAlign.hpp"
+
+PrefixSuffixAlign::PrefixSuffixAlign() {}
+
+PrefixSuffixAlign::PrefixSuffixAlign(std::string s1, std::string s2) : PairwiseAlign(s1, s2) { }
+
+// unable to figure out how to properly overload constructor using RICE
+//PrefixSuffixAlign::PrefixSuffixAlign(std::string s1, std::string s2, int matchS, int mismatchS, int indelS) : PairwiseAlign(s1, s2, matchS, mismatchS, indelS) {}
+
+std::string PrefixSuffixAlign::getAlignment() {
+  TSequence tseq1 = seq1;
+  TSequence tseq2 = seq2;
+
+  TStringSet sequences;
+  appendValue(sequences,tseq1);
+  appendValue(sequences,tseq2);
+
+  TAlignGraph alignG(sequences);
+  
+  // don't penalize gaps on begin/end of seq2
+  globalAlignment(alignG, Score<int,Simple>(matchScore,mismatchScore,indelScore), AlignConfig<true, false, false, true>(), NeedlemanWunsch());
+
+  std::stringstream ss;
+  ss<<alignG;
+  return ss.str();
+}
+
+
+void PrefixSuffixAlign::run() {
+  TSequence tseq1 = seq1;
+  TSequence tseq2 = seq2;
+
+  TStringSet sequences;
+  appendValue(sequences,tseq1);
+  appendValue(sequences,tseq2);
+
+  TAlignGraph alignG(sequences);
+  
+  // don't penalize gaps on begin/end of seq2
+  score = globalAlignment(alignG, Score<int,Simple>(matchScore,mismatchScore,indelScore), AlignConfig<true, false, false, true>(), NeedlemanWunsch());
+  
+}

data/ext/bioseqalign/PrefixSuffixAlign.hpp

@@ -0,0 +1,30 @@
+/**
+ * Perform prefix-suffix alignment, aligning the prefix of seq1
+ * with the suffix of seq2
+ * ex:  seq1:  --------YYYYYYYZZZZZZ
+ *      seq2:  XXXXXXXXYYYYYYY------
+ */
+
+#include <iostream>
+#include <string>
+#include <seqan/align.h>
+
+#include "PairwiseAlign.hpp"
+
+using namespace seqan;
+
+
+class PrefixSuffixAlign : public PairwiseAlign {
+public:
+  PrefixSuffixAlign();
+  PrefixSuffixAlign(std::string s1, std::string s2);
+  virtual ~PrefixSuffixAlign() {}
+  
+  virtual void run();
+  //virtual std::string getAlignment();
+  //Rice::Array getAlignmentArray();
+  virtual Rice::Array getAlignment();
+  
+};
+
+

data/ext/bioseqalign/PrefixSuffixAlign.hpp~

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <string>
+#include <seqan/align.h>
+
+#include "PairwiseAlign.hpp"
+
+using namespace seqan;
+
+class PrefixSuffixAlign : public PairwiseAlign {
+public:
+  FitAlign();
+  FitAlign(std::string s1, std::string s2);
+  //FitAlign(std::string s1, std::string s2, int matchS, int mismatchS, int indelS);
+  virtual ~FitAlign() {}
+  
+  virtual void run();
+  virtual std::string getAlignment();
+  
+};
+

data/ext/bioseqalign/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf-rice'
+create_makefile('SeqAlign')

data/ext/bioseqalign/extconf.rb~

@@ -0,0 +1,2 @@
+require 'mkmf-rice'
+create_makefile('FitAlign')

data/ext/bioseqalign/fitalgntest.cpp

@@ -0,0 +1,49 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+//#include "PairwiseAlign.hpp"
+#include "FitAlign.hpp"
+#include "PrefixSuffixAlign.hpp"
+#include "LocalAlign.hpp"
+#include "GlobalAlign.hpp"
+
+using namespace Rice;
+
+extern "C"
+
+//void Init_FitAlign()
+void Init_SeqAlign()
+{
+  Data_Type<PairwiseAlign> rb_cPairwiseAlign = define_class<PairwiseAlign>("PairwiseAlign")
+    .define_constructor(Constructor<PairwiseAlign>())
+    .define_constructor(Constructor<PairwiseAlign,std::string,std::string>())
+    //.define_constructor(Constructor<PairwiseAlign,std::string,std::string,int,int,int>())
+    .define_method("getAlignScore", &PairwiseAlign::getAlignScore)
+    .define_method("getSeq1", &PairwiseAlign::getSeq1)
+    .define_method("getSeq2", &PairwiseAlign::getSeq2)
+    .define_method("run", &PairwiseAlign::run)
+    .define_method("getAlignment", &PairwiseAlign::getAlignment)
+    .define_method("setMatchScore", &PairwiseAlign::setMatchScore)
+    .define_method("setMismatchScore", &PairwiseAlign::setMismatchScore)
+    .define_method("setIndelScore", &PairwiseAlign::setIndelScore);
+  Data_Type<FitAlign> rb_cFitAlign = define_class<FitAlign,PairwiseAlign>("FitAlign")
+    .define_constructor(Constructor<FitAlign>())
+    .define_constructor(Constructor<FitAlign,std::string,std::string>())
+    //.define_constructor(Constructor<FitAlign,std::string,std::string,int,int,int>())
+    .define_method("run", &FitAlign::run)
+    .define_method("getAlignment", &FitAlign::getAlignment);
+  Data_Type<PrefixSuffixAlign> rb_cPrefixSuffixAlign = define_class<PrefixSuffixAlign,PairwiseAlign>("PrefixSuffixAlign")
+    .define_constructor(Constructor<PrefixSuffixAlign>())
+    .define_constructor(Constructor<PrefixSuffixAlign,std::string,std::string>())
+    .define_method("run", &PrefixSuffixAlign::run)
+    .define_method("getAlignment", &PrefixSuffixAlign::getAlignment);
+  Data_Type<LocalAlign> rb_cLocalAlign = define_class<LocalAlign,PairwiseAlign>("LocalAlign")
+    .define_constructor(Constructor<LocalAlign>())
+    .define_constructor(Constructor<LocalAlign,std::string,std::string>())
+    .define_method("run", &LocalAlign::run)
+    .define_method("getAlignment", &LocalAlign::getAlignment);
+  Data_Type<GlobalAlign> rb_cGlobalAlign = define_class<GlobalAlign,PairwiseAlign>("GlobalAlign")
+    .define_constructor(Constructor<GlobalAlign>())
+    .define_constructor(Constructor<GlobalAlign,std::string,std::string>())
+    .define_method("run", &GlobalAlign::run)
+    .define_method("getAlignment", &GlobalAlign::getAlignment);
+}

data/ext/bioseqalign/fitalgntest.cpp~

@@ -0,0 +1,37 @@
+#include "rice/Data_Type.hpp"
+#include "rice/Constructor.hpp"
+//#include "PairwiseAlign.hpp"
+#include "FitAlign.hpp"
+#include "PrefixSuffixAlign.hpp"
+using namespace Rice;
+
+extern "C"
+
+//void Init_FitAlign()
+void Init_SeqAlign()
+{
+  Data_Type<PairwiseAlign> rb_cPairwiseAlign = define_class<PairwiseAlign>("PairwiseAlign")
+    .define_constructor(Constructor<PairwiseAlign>())
+    .define_constructor(Constructor<PairwiseAlign,std::string,std::string>())
+    //.define_constructor(Constructor<PairwiseAlign,std::string,std::string,int,int,int>())
+    .define_method("getAlignScore", &PairwiseAlign::getAlignScore)
+    .define_method("getSeq1", &PairwiseAlign::getSeq1)
+    .define_method("getSeq2", &PairwiseAlign::getSeq2)
+    .define_method("run", &PairwiseAlign::run)
+    .define_method("getAlignment", &PairwiseAlign::getAlignment)
+    .define_method("setMatchScore", &PairwiseAlign::setMatchScore)
+    .define_method("setMismatchScore", &PairwiseAlign::setMismatchScore)
+    .define_method("setIndelScore", &PairwiseAlign::setIndelScore);
+  Data_Type<FitAlign> rb_cFitAlign = define_class<FitAlign,PairwiseAlign>("FitAlign")
+    .define_constructor(Constructor<FitAlign>())
+    .define_constructor(Constructor<FitAlign,std::string,std::string>())
+    //.define_constructor(Constructor<FitAlign,std::string,std::string,int,int,int>())
+    .define_method("run", &FitAlign::run)
+    .define_method("getAlignment", &FitAlign::getAlignment);
+  Data_Type<PrefixSuffixAlign> rb_cPrefixSuffixAlign = define_class<PrefixSuffixAlign,PairwiseAlign>("PrefixSuffixAlign")
+    .define_constructor(Constructor<PrefixSuffixAlign>())
+    .define_constructor(Constructor<PrefixSuffixAlign,std::string,std::string>())
+    .define_method("run", &PrefixSuffixAlign::run)
+    .define_method("getAlignment", &PrefixSuffixAlign::getAlignment);
+    //.define_method("getAlignmentArray", &PrefixSuffixAlign::getAlignmentArray);
+}

data/ext/bioseqalign/runTest.rb

@@ -0,0 +1,17 @@
+#require './PairwiseAlign'
+#require './FitAlign'
+require './SeqAlign'
+
+sa = PairwiseAlign.new("TCGA", "TCGA")
+puts sa.getSeq1
+
+#__END__
+fa = FitAlign.new("AAAAAAAATCGAGGG", "TCGA")
+fa.setMatchScore(2)
+fa.setMismatchScore(-1)
+fa.setIndelScore(-1)
+puts fa.getSeq1
+fa.run
+puts fa.getAlignScore
+puts fa.getAlignment
+

data/ext/bioseqalign/runTest.rb~

@@ -0,0 +1,8 @@
+require './FitAlign'
+
+fa = FitAlign.new("TCGA", "TCGA")
+puts fa.getSeq1
+fa.run
+puts fa.getAlignScore
+puts fa.getAlignment
+