bio-bwa 0.2.0

data/ext/stdaln.h

@@ -0,0 +1,162 @@
+/* The MIT License
+
+   Copyright (c) 2003-2006, 2008, by Heng Li <lh3lh3@gmail.com>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/*
+  2009-07-23, 0.10.0
+
+  - Use 32-bit to store CIGAR
+
+  - Report suboptimal aligments
+
+  - Implemented half-fixed-half-open DP
+
+  2009-04-26, 0.9.10
+
+  - Allow to set a threshold for local alignment
+
+  2009-02-18, 0.9.9
+
+  - Fixed a bug when no residue matches
+
+  2008-08-04, 0.9.8
+
+  - Fixed the wrong declaration of aln_stdaln_aux()
+
+  - Avoid 0 coordinate for global alignment
+
+  2008-08-01, 0.9.7
+
+  - Change gap_end penalty to 5 in aln_param_bwa
+
+  - Add function to convert path_t to the CIGAR format
+
+  2008-08-01, 0.9.6
+
+  - The first gap now costs (gap_open+gap_ext), instead of
+    gap_open. Scoring systems are modified accordingly.
+
+  - Gap end is now correctly handled. Previously it is not correct.
+
+  - Change license to MIT.
+
+ */
+
+#ifndef LH3_STDALN_H_
+#define LH3_STDALN_H_
+
+
+#define STDALN_VERSION 0.11.0
+
+#include <stdint.h>
+
+#define FROM_M 0
+#define FROM_I 1
+#define FROM_D 2
+#define FROM_S 3
+
+#define ALN_TYPE_LOCAL  0
+#define ALN_TYPE_GLOBAL 1
+#define ALN_TYPE_EXTEND 2
+
+/* This is the smallest integer. It might be CPU-dependent in very RARE cases. */
+#define MINOR_INF -1073741823
+
+typedef struct
+{
+	int gap_open;
+	int gap_ext;
+	int gap_end;
+
+	int *matrix;
+	int row;
+	int band_width;
+} AlnParam;
+
+typedef struct
+{
+	int i, j;
+	unsigned char ctype;
+} path_t;
+
+typedef struct
+{
+	path_t *path; /* for advanced users... :-) */
+	int path_len; /* for advanced users... :-) */
+	int start1, end1; /* start and end of the first sequence, coordinations are 1-based */
+	int start2, end2; /* start and end of the second sequence, coordinations are 1-based */
+	int score, subo; /* score */
+
+	char *out1, *out2; /* print them, and then you will know */
+	char *outm;
+
+	int n_cigar;
+	uint32_t *cigar32;
+} AlnAln;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	AlnAln *aln_stdaln_aux(const char *seq1, const char *seq2, const AlnParam *ap,
+						   int type, int do_align, int len1, int len2);
+	AlnAln *aln_stdaln(const char *seq1, const char *seq2, const AlnParam *ap, int type, int do_align);
+	void aln_free_AlnAln(AlnAln *aa);
+
+	int aln_global_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap,
+						path_t *path, int *path_len);
+	int aln_local_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap,
+					   path_t *path, int *path_len, int _thres, int *_subo);
+	int aln_extend_core(unsigned char *seq1, int len1, unsigned char *seq2, int len2, const AlnParam *ap,
+						path_t *path, int *path_len, int G0, uint8_t *_mem);
+	uint16_t *aln_path2cigar(const path_t *path, int path_len, int *n_cigar);
+	uint32_t *aln_path2cigar32(const path_t *path, int path_len, int *n_cigar);
+
+#ifdef __cplusplus
+}
+#endif
+
+/********************
+ * global variables *
+ ********************/
+
+extern AlnParam aln_param_bwa;   /* = { 37,  9,  0, aln_sm_maq, 5, 50 }; */
+extern AlnParam aln_param_blast; /* = {  5,  2,  2, aln_sm_blast, 5, 50 }; */
+extern AlnParam aln_param_nt2nt; /* = { 10,  2,  2, aln_sm_nt, 16, 75 }; */
+extern AlnParam aln_param_aa2aa; /* = { 20, 19, 19, aln_sm_read, 16, 75 }; */
+extern AlnParam aln_param_rd2rd; /* = { 12,  2,  2, aln_sm_blosum62, 22, 50 }; */
+
+/* common nucleotide score matrix for 16 bases */
+extern int           aln_sm_nt[], aln_sm_bwa[];
+
+/* BLOSUM62 and BLOSUM45 */
+extern int           aln_sm_blosum62[], aln_sm_blosum45[];
+
+/* common read for 16 bases. note that read alignment is quite different from common nucleotide alignment */
+extern int           aln_sm_read[];
+
+/* human-mouse score matrix for 4 bases */
+extern int           aln_sm_hs[];
+
+#endif

data/ext/utils.c

@@ -0,0 +1,82 @@
+/* The MIT License
+
+   Copyright (c) 2008 Genome Research Ltd (GRL).
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/* Contact: Heng Li <lh3@sanger.ac.uk> */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <zlib.h>
+#include "utils.h"
+
+FILE *err_xopen_core(const char *func, const char *fn, const char *mode)
+{
+	FILE *fp = 0;
+	if (strcmp(fn, "-") == 0)
+		return (strstr(mode, "r"))? stdin : stdout;
+	if ((fp = fopen(fn, mode)) == 0) {
+		fprintf(stderr, "[%s] fail to open file '%s'. Abort!\n", func, fn);
+		abort();
+	}
+	return fp;
+}
+FILE *err_xreopen_core(const char *func, const char *fn, const char *mode, FILE *fp)
+{
+	if (freopen(fn, mode, fp) == 0) {
+		fprintf(stderr, "[%s] fail to open file '%s': ", func, fn);
+		perror(NULL);
+		fprintf(stderr, "Abort!\n");
+		abort();
+	}
+	return fp;
+}
+gzFile err_xzopen_core(const char *func, const char *fn, const char *mode)
+{
+	gzFile fp;
+	if (strcmp(fn, "-") == 0)
+		return gzdopen(fileno((strstr(mode, "r"))? stdin : stdout), mode);
+	if ((fp = gzopen(fn, mode)) == 0) {
+		fprintf(stderr, "[%s] fail to open file '%s'. Abort!\n", func, fn);
+		abort();
+	}
+	return fp;
+}
+void err_fatal(const char *header, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	fprintf(stderr, "[%s] ", header);
+	vfprintf(stderr, fmt, args);
+	fprintf(stderr, " Abort!\n");
+	va_end(args);
+	abort();
+}
+
+void err_fatal_simple_core(const char *func, const char *msg)
+{
+	fprintf(stderr, "[%s] %s Abort!\n", func, msg);
+	abort();
+}

data/ext/utils.h

@@ -0,0 +1,54 @@
+/* The MIT License
+
+   Copyright (c) 2008 Genome Research Ltd (GRL).
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/* Contact: Heng Li <lh3@sanger.ac.uk> */
+
+#ifndef LH3_UTILS_H
+#define LH3_UTILS_H
+
+#include <stdio.h>
+#include <zlib.h>
+
+#define err_fatal_simple(msg) err_fatal_simple_core(__func__, msg)
+#define xopen(fn, mode) err_xopen_core(__func__, fn, mode)
+#define xreopen(fn, mode, fp) err_xreopen_core(__func__, fn, mode, fp)
+#define xzopen(fn, mode) err_xzopen_core(__func__, fn, mode)
+#define xassert(cond, msg) if ((cond) == 0) err_fatal_simple_core(__func__, msg)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	void err_fatal(const char *header, const char *fmt, ...);
+	void err_fatal_simple_core(const char *func, const char *msg);
+	FILE *err_xopen_core(const char *func, const char *fn, const char *mode);
+	FILE *err_xreopen_core(const char *func, const char *fn, const char *mode, FILE *fp);
+	gzFile err_xzopen_core(const char *func, const char *fn, const char *mode);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/lib/bio-bwa.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'ffi'
+require 'bio/bwa/library'
+require 'bio/bwa'
+  
+
+

data/lib/bio/bwa.rb

@@ -0,0 +1,312 @@
+module Bio
+  # @author Francesco Strozzi https://github.com/fstrozzi
+  class BWA
+      extend FFI::Library
+      ffi_lib Bio::BWA::Library.load
+      
+      # Convert a Fasta to Packed format
+      # @param [Hash]. params Options.
+      # @option params [String] :file_in the Fasta or FastQ file (REQUIRED)
+      # @option params [String] :prefix the prefix name for the PAC file
+      def self.fa2pac(params={})
+        valid_params = %q(file_in prefix)
+        last_params = [:file_in, :prefix]
+        mandatory_params = [:file_in]
+        check_mandatory(mandatory_params, params)
+        args = build_parameters("fa2pac",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      # Convert a Packed file format to Burrows-Wheeler Transform format
+      # @param [Hash]. params Options.
+      # @option params [String] :file_in the PAC file (REQUIRED)
+      # @option params [String] :file_out the name of the BWT file (REQUIRED)
+      def self.pac2bwt(params={})
+        valid_params = %q(file_in file_out)
+        last_params = [:file_in,:file_out]
+        check_mandatory(last_params, params)
+        args = build_parameters("pac2bwt",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      # Convert a BWT file to the new BWT format
+      # @param [Hash]. params Options.
+      # @option params [String] :file_in the BWT file (REQUIRED)
+      # @note this method overwrite existing BWT file
+      def self.bwtupdate(params={})
+        valid_params = %w(file_in)
+        last_params = [:file_in]
+        check_mandatory(last_params, params)
+        args = build_parameters("bwtupdate",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      # Generate reverse Packed format
+      # @param [Hash]. params Options.      
+      # @option params [String] :file_in the PAC file (REQUIRED)
+      # @option params [String] :file_out the name of the REV PAC (REQUIRED)
+      def self.pac_rev(params={})
+        valid_params = %w(file_in file_out)
+        last_params = [:file_in,:file_out]
+        check_mandatory(last_params, params)
+        args = build_parameters("pac_rev",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      # Generate SA file from BWT and Occ files
+      # @param [Hash]. params Options.
+      # @option params [String] :file_in the PAC file (REQUIRED)
+      # @option params [String] :file_out the name of the REV PAC (REQUIRED)
+      def self.bwt2sa(params={})
+        valid_params = %q(file_in file_out i)
+        last_params = [:file_in,:file_out]
+        check_mandatory(last_params, params)
+        args = build_parameters("bwt2sa",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      # Generate the BWT index for a Fasta database
+      # @param [Hash]. params Options.
+      # @option params [String] :file_in the Fasta file (REQUIRED)
+      # @option params [String] :p the prefix for the database files that will be generated [default is Fasta name]
+      # @option params [String] :a the algorithm to be used for indexing: 'is' (short database)[default] or 'bwtsw' (long database)
+      # @option params [Boolean] :c colorspace database index
+      # @note Boolean values must be set to 'true'
+      def self.make_index(params = {})
+        valid_params = %w(file_in p a c)
+        mandatory_params = [:file_in]
+        last_params = [:file_in]
+        check_mandatory(mandatory_params, params)
+        params = change_arg_name(params,:prefix,:p) if params[:prefix]
+        args = build_parameters("index",valid_params,params,last_params)        
+        call_BWA_function(args)
+      end
+      
+      # Run the alignment for short query sequences
+      # @param [Hash] params Options
+      # @option params [String] :file_in the FastQ file (REQUIRED)
+      # @option params [String] :prefix the prefix of the database index files (REQUIRED)
+      # @option params [String] :file_out the output of the alignment in SAI format (REQUIRED)
+      # @option params [Integer] :n max #diff (int) or missing prob under 0.02 err rate (float) [0.04]
+      # @option params [Integer] :o maximum number or fraction of gap opens [1]
+      # @option params [Integer] :e maximum number of gap extensions, -1 for disabling long gaps [-1]
+      # @option params [Integer] :m maximum entries in the queue [2000000]
+      # @option params [Integer] :t number of threads [1]
+      # @option params [Integer] :M mismatch penalty [3]
+      # @option params [Integer] :O gap open penalty [11]
+      # @option params [Integer] :R stop searching when there are >INT equally best hits [30]
+      # @option params [Integer] :q quality threshold for read trimming down to 35bp [0]
+      # @option params [Integer] :B length of barcode
+      # @option params [Boolean] :c input sequences are in the color space
+      # @option params [Boolean] :L log-scaled gap penalty for long deletions
+      # @option params [Boolean] :N non-iterative mode: search for all n-difference hits (slow)
+      # @option params [Boolean] :I the input is in the Illumina 1.3+ FASTQ-like format
+      # @option params [Boolean] :b the input read file is in the BAM format
+      # @option params [Boolean] :single use single-end reads only (effective with -b)
+      # @option params [Boolean] :first use the 1st read in a pair (effective with -b)
+      # @option params [Boolean] :second use the 2nd read in a pair (effective with -b)
+      # @option params [Integer] :i do not put an indel within INT bp towards the ends [5]
+      # @option params [Integer] :d maximum occurrences for extending a long deletion [10]
+      # @option params [Integer] :l seed length [32]
+      # @option params [Integer] :k maximum differences in the seed [2]
+      # @option params [Integer] :E gap extension penalty [4]
+      # @note Boolean values must be set to 'true'
+      def self.short_read_alignment(params={})
+          args = ["aln"]
+          valid_params = %w(n o e i d l k c L R m t N M O E q f b single first second I B prefix file_in)
+          mandatory_params = [:prefix,:file_in,:file_out]
+          last_params = [:prefix,:file_in]
+          check_mandatory(mandatory_params, params)
+          params = change_arg_name(params,:file_out,:f) if params[:file_out]
+          params = change_arg_name(params,:single,"0") if params[:single]
+          params = change_arg_name(params,:first,"1") if params[:first]   
+          params = change_arg_name(params,:second,"2") if params[:second]
+          args = build_parameters("aln",valid_params,params,last_params)
+          call_BWA_function(args)
+      end
+      
+      # Convert the SAI alignment output into SAM format (single end)
+      # @param [Hash] params Options
+      # @option params [String] :fastq the FastQ file (REQUIRED)
+      # @option params [String] :prefix the prefix of the database index files (REQUIRED)
+      # @option params [String] :sai the alignment file in SAI format (REQUIRED)
+      # @option params [String] :file_out the file name of the SAM output
+      # @option params [Integer] :n max_occ
+      # @option params [String] :r RG_line
+      def self.sai_to_sam_single(params = {})
+        valid_params = %w(n r fastq sai prefix f)
+        mandatory_params = [:prefix,:sai,:fastq]
+        last_params = [:prefix,:sai,:fastq]
+        check_mandatory(mandatory_params, params)
+        params = change_arg_name(params,:file_out,:f) if params[:file_out]
+        args = build_parameters("sai2sam_se",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      
+      # Convert the SAI alignment output into SAM format (paired ends)
+      # @param [Hash] params Options
+      # @option params [String] :prefix the prefix of the database index files (REQUIRED)
+      # @option params [Array] :sai the two alignment files in SAI format (REQUIRED)
+      # @option params [Array] :fastq the two fastq files (REQUIRED)
+      # @option params [Integer] :a maximum insert size [500]
+      # @option params [Integer] :o maximum occurrences for one end [100000]
+      # @option params [Integer] :n maximum hits to output for paired reads [3]
+      # @option params [Integer] :N maximum hits to output for discordant pairs [10]
+      # @option params [Float] :c prior of chimeric rate (lower bound) [1.0e-05]
+      # @option params [String] :r read group header line such as '@RG\tID:foo\tSM:bar'
+      # @option params [Boolean] :P preload index into memory (for base-space reads only)
+      # @option params [Boolean] :s disable Smith-Waterman for the unmapped mate
+      # @option params [Boolean] :A disable insert size estimate (force :s)
+      # @note Boolean values must be set to 'true'
+      def self.sai_to_sam_paired(params = {})
+        valid_params = %w(a o s P n N c f A r prefix first_sai second_sai first_fastq second_fastq)
+        mandatory_params = [:prefix, :sai, :fastq]
+        last_params = [:prefix, :first_sai, :second_sai, :first_fastq, :second_fastq]
+        check_mandatory(mandatory_params, params)
+        params = change_arg_name(params,:file_out,:f) if params[:file_out]
+        if params[:sai]
+          raise ArgumentError,"you must provide an array with two SAI files!" unless params[:sai].is_a?(Array) and params[:sai].size == 2
+          params[:first_sai] = params[:sai][0]
+          params[:second_sai] = params[:sai][1]
+          params.delete(:sai)
+        end
+        if params[:fastq]
+          raise ArgumentError,"you must provide an array with two FastQ files!" unless params[:fastq].is_a?(Array) and params[:fastq].size == 2
+          params[:first_fastq] = params[:fastq][0]
+          params[:second_fastq] = params[:fastq][1]
+          params.delete(:fastq)
+        end
+        args = build_parameters("sai2sam_pe",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      # Run the alignment for long query sequences
+      # @param [Hash] params Options
+      # @option params [String] :file_in the FastQ file (REQUIRED)
+      # @option params [String] :prefix the prefix of the database index files (REQUIRED)
+      # @option params [String] :file_out the output of the alignment in SAM format (REQUIRED)
+      # @option params [Integer] :a score for a match [1]
+      # @option params [Integer] :b mismatch penalty [3]
+      # @option params [Integer] :q gap open penalty [5]
+      # @option params [Integer] :r gap extension penalty [2]
+      # @option params [Integer] :t number of threads [1]
+      # @option params [Integer] :w band width [50]
+      # @option params [Float] :m mask level [0.50]
+      # @option params [Integer] :T score threshold divided by a [30]
+      # @option params [Integer] :s maximum seeding interval size [3]
+      # @option params [Integer] :z Z-best [1]
+      # @option params [Integer] :N number of seeds to trigger reverse alignment [5]
+      # @option params [Float] :c coefficient of length-threshold adjustment [5.5]
+      # @option params [Boolean] :H in SAM output, use hard clipping rather than soft
+      # @note Boolean arguments must be set to 'true'
+      def self.long_read_alignment(params = {})
+        valid_params = %w(q r a b t T w d z m y s c N H f prefix file_in)
+        mandatory_params = [:prefix, :file_in, :file_out]
+        last_params = [:prefix,:file_in]
+        check_mandatory(mandatory_params, params)
+        params = change_arg_name(params,:file_out,:f) if params[:file_out]  
+        args = build_parameters("bwtsw2",valid_params,params,last_params)
+        call_BWA_function(args)
+      end
+      
+      # Run the alignment between multiple short sequences and ONE long sequence
+      # @param [Hash] params Options
+      # @option params [String] :short_seq the short query sequence (REQUIRED)
+      # @option params [String] :long_seq the long database sequence (REQUIRED)
+      # @option params [String] :file_out the alignment output
+      # @option params [Integer] :T minimum score [1]
+      # @option params [Boolean] :p protein alignment (suppressing :r)
+      # @option params [Boolean] :f forward strand only
+      # @option params [Boolean] :r reverse strand only
+      # @option params [Boolean] :g global alignment
+      # @note Boolean values must be set to 'true'
+      def self.simple_SW(params = {})
+        args = ["stdsw"]
+        valid_params = %w(g T f r p file_out long_seq short_seq)
+        mandatory_params = [:long_seq,:short_seq]
+        last_params = mandatory_params
+        check_mandatory(mandatory_params, params)
+        file_out = params[:file_out]
+        params.delete(:file_out)
+        args = build_parameters("stdsw",valid_params,params,last_params)
+        $stdout.reopen(file_out,"w") if file_out
+        call_BWA_function(args)
+        $stdout.reopen("/dev/tty","w") if file_out
+      end
+      
+      
+      
+      ######## Methods to handle C functions and arguments ########
+      
+      attach_function :bwa_fa2pac, [:int,:pointer], :int
+      attach_function :bwa_pac2bwt, [:int,:pointer], :int
+      attach_function :bwa_bwtupdate, [:int,:pointer], :int
+      attach_function :bwa_pac_rev, [:int,:pointer], :int
+      attach_function :bwa_bwt2sa, [:int,:pointer], :int
+      attach_function :bwa_index, [:int,:pointer], :int
+      attach_function :bwa_aln, [:int,:pointer], :int
+      attach_function :bwa_sai2sam_se, [:int, :pointer], :int
+      attach_function :bwa_sai2sam_pe, [:int,:pointer], :int
+      attach_function :bwa_bwtsw2, [:int, :pointer], :int
+      attach_function :bwa_stdsw, [:int, :pointer], :int
+      
+      # Internal method to call the BWA C functions
+      # @note this method should not be called directly   
+      def self.call_BWA_function(args)
+        c_args = build_args_for_BWA(args)  
+        self.send("bwa_#{args[0]}".to_sym,args.size,c_args) # call the C function and pass the arguments size and parameters list (same as int argc, char *argv[])
+      end 
+      
+      # Internal method to build argument list for BWA C functions
+      # @note this method should not be called directly
+      def self.build_args_for_BWA(args)
+        cmd_args = args.map do |arg|
+          FFI::MemoryPointer.from_string(arg.to_s) # convert every parameters into a string and then into a memory pointer
+        end
+        exec_args = FFI::MemoryPointer.new(:pointer, cmd_args.length) # creating a pointer to an array of pointers
+        cmd_args.each_with_index do |arg, i|
+          exec_args[i].put_pointer(0, arg) # filling in the array of pointers
+        end
+        return exec_args
+      end
+      
+      # Internal method to produce a correct parameter list for BWA functions
+      # @note this method should not be called directly
+      def self.build_parameters(function_name,valid_params,params,last_params)
+        args = [function_name]
+        params.each_key do |k|
+          raise ArgumentError, "Unknown parameter '#{k}'" unless valid_params.include?(k.to_s)
+          if params[k] and !last_params.include?(k) then # check if value exists and if is not a last_params (required at the end of BWA functions)
+            args << "-#{k}"
+            args << params[k] unless params[k] == true # skipping boolean values. just include the param name
+          end
+        end                
+        last_params.each {|p| args << params[p]} # now adding the last_params so the parameter list is in the correct order for BWA functions
+        return args
+      end
+      
+      # Internal method to check if mandatory params have been set
+      # @note this method should not be called directly
+      def self.check_mandatory(mandatory_params, params)
+        mandatory_params.each {|mp| raise ArgumentError,"You must provide parameter '#{mp}'" unless params.include?(mp)}
+      end
+      
+      # Internal method used to change parameters name from Ruby to BWA functions
+      # @note this method should not be called directly
+      def self.change_arg_name(hash,key,new_key)
+        hash[new_key] = hash[key]
+        hash.delete(key)
+        return hash
+      end
+      
+      private_class_method :call_BWA_function
+      private_class_method :build_args_for_BWA
+      private_class_method :build_parameters
+      private_class_method :check_mandatory
+      
+  end
+end
+
+
+