├── lib ├── CMakeLists.txt └── wavelib │ ├── unitTests │ ├── CMakeLists.txt │ └── wavelibBoostTests │ │ ├── BoostTest.cpp │ │ ├── BoostTest.h │ │ └── CMakeLists.txt │ ├── .gitignore │ ├── src │ ├── cwtmath.h │ ├── wavefunc.h │ ├── CMakeLists.txt │ ├── real.h │ ├── cwt.h │ ├── wavefilt.h │ ├── wtmath.h │ ├── conv.h │ ├── hsfft.h │ ├── real.c │ ├── conv.c │ ├── wavefunc.c │ ├── wtmath.c │ ├── wavelib.h │ ├── cwtmath.c │ └── cwt.c │ ├── test │ ├── wtreetest.c │ ├── dwpttest.c │ ├── modwttest.c │ ├── swttest.c │ ├── dwttest.c │ ├── signal.txt │ ├── cwttest.c │ └── sst_nino3.dat │ ├── CMakeLists.txt │ └── header │ └── wavelib.h ├── src ├── kmer │ ├── 6mer_index_official.rc │ ├── CMakeLists.txt │ ├── kmer_index.h │ ├── kmer_index.cpp │ └── 5mer_index_mapping ├── main │ ├── CMakeLists.txt │ ├── opts.h │ └── main.cpp ├── seq2sig │ ├── CMakeLists.txt │ ├── opts.h │ └── main.cpp ├── sig2peak │ ├── CMakeLists.txt │ ├── main.cpp │ └── opts.h ├── CMakeLists.txt ├── util │ ├── exception.cpp │ ├── CMakeLists.txt │ ├── qsort.h │ ├── exception.h │ ├── qsort.cpp │ └── matrix.h └── proc │ ├── CMakeLists.txt │ ├── io.h │ ├── cwdtw.h │ ├── proc.h │ ├── io.cpp │ └── cwdtw.cpp ├── cwDTW ├── seq2sig ├── sig2peak ├── install.sh ├── CMakeLists.txt ├── README └── example ├── 0a0dc008-5d60-4f7f-aa24-c78da021f7bf.fasta └── 002a08b9-0248-4929-9759-2d5c0942076d.fasta /lib/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_subdirectory(wavelib) 2 | -------------------------------------------------------------------------------- /src/kmer/6mer_index_official.rc: -------------------------------------------------------------------------------- 1 | 6mer_index_official.origin -------------------------------------------------------------------------------- /cwDTW: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/realbigws/cwDTW/HEAD/cwDTW -------------------------------------------------------------------------------- /seq2sig: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/realbigws/cwDTW/HEAD/seq2sig -------------------------------------------------------------------------------- /sig2peak: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/realbigws/cwDTW/HEAD/sig2peak -------------------------------------------------------------------------------- /lib/wavelib/unitTests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | add_subdirectory(wavelibBoostTests) 3 | 4 | -------------------------------------------------------------------------------- /src/main/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | MESSAGE(STATUS "building main") 3 | 4 | add_executable(wletdtw main.cpp) 5 | target_link_libraries(wletdtw proc m wavelib) 6 | -------------------------------------------------------------------------------- /lib/wavelib/unitTests/wavelibBoostTests/BoostTest.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | #define BOOST_TEST_MODULE WaveLibTests 4 | 5 | #include 6 | -------------------------------------------------------------------------------- /src/seq2sig/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | MESSAGE(STATUS "building seq2sig") 3 | 4 | add_executable(seq2sig main.cpp) 5 | 6 | target_link_libraries(seq2sig kmer proc m) 7 | -------------------------------------------------------------------------------- /src/sig2peak/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | MESSAGE(STATUS "building sig2peak") 3 | 4 | add_executable(sig2peak main.cpp) 5 | target_link_libraries(sig2peak proc m wavelib) 6 | 7 | 8 | -------------------------------------------------------------------------------- /src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | add_subdirectory(main) 3 | add_subdirectory(util) 4 | add_subdirectory(kmer) 5 | add_subdirectory(proc) 6 | add_subdirectory(seq2sig) 7 | add_subdirectory(sig2peak) 8 | -------------------------------------------------------------------------------- /src/util/exception.cpp: -------------------------------------------------------------------------------- 1 | #include "exception.h" 2 | 3 | void ex::EX_THROW(const char* x) 4 | { 5 | std::ostringstream oss; 6 | oss << x; 7 | throw Exception(oss.str()); 8 | } -------------------------------------------------------------------------------- /lib/wavelib/unitTests/wavelibBoostTests/BoostTest.h: -------------------------------------------------------------------------------- 1 | 2 | 3 | #ifndef SWALLOWING_BOOSTTEST_H_ 4 | #define SWALLOWING_BOOSTTEST_H_ 5 | 6 | // we use the header only version of boost unit test 7 | #define BOOST_TEST_NO_LIB 8 | #include 9 | 10 | #endif // SWALLOWING_BOOSTTEST_H_ 11 | -------------------------------------------------------------------------------- /lib/wavelib/.gitignore: -------------------------------------------------------------------------------- 1 | #Folders Ignore 2 | Bin/ 3 | Testing/ 4 | 5 | #cmake ignore 6 | CMakeCache.txt 7 | CMakeFiles/ 8 | CMakeScripts/ 9 | Makefile/ 10 | cmake_install.cmake 11 | install_manifest.txt 12 | 13 | #yml 14 | *.yml 15 | 16 | #Compiled 17 | *.a 18 | *.o 19 | *.lib 20 | *.so 21 | *.exe 22 | *.dll 23 | -------------------------------------------------------------------------------- /src/kmer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | aux_source_directory(. MER_SRCS) 3 | 4 | MESSAGE(STATUS "building kmer") 5 | 6 | add_library (kmer STATIC ${MER_SRCS}) 7 | 8 | target_link_libraries(kmer) 9 | 10 | set_target_properties(kmer PROPERTIES OUTPUT_NAME "kmer") 11 | set_target_properties(kmer PROPERTIES CLEAN_DIRECT_OUTPUT 1) 12 | -------------------------------------------------------------------------------- /src/proc/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | aux_source_directory(. PROC_SRCS) 3 | 4 | MESSAGE(STATUS "building proc") 5 | 6 | include_directories(${PROJECT_SOURCE_DIR}) 7 | 8 | add_library (proc STATIC ${PROC_SRCS}) 9 | 10 | target_link_libraries(proc wavelib) 11 | 12 | set_target_properties(proc PROPERTIES OUTPUT_NAME "proc") 13 | set_target_properties(proc PROPERTIES CLEAN_DIRECT_OUTPUT 1) 14 | -------------------------------------------------------------------------------- /src/util/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | #set(UTIL_SRCS exception.cpp dataf.cpp) 3 | aux_source_directory(. UTIL_SRCS) 4 | 5 | MESSAGE(STATUS "building util") 6 | 7 | include_directories(${PROJECT_SOURCE_DIR}) 8 | 9 | add_library (util STATIC ${UTIL_SRCS}) 10 | 11 | target_link_libraries(util) 12 | 13 | set_target_properties(util PROPERTIES OUTPUT_NAME "util") 14 | set_target_properties(util PROPERTIES CLEAN_DIRECT_OUTPUT 1) -------------------------------------------------------------------------------- /install.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | if [ -f "cwDTW" ] && [ -f "seq2sig" ] && [ -f "sig2peak" ] 4 | then 5 | echo " executable files 'cwDTW', 'seq2sig' and 'sig2peak' already been compiled. " 6 | exit 1 7 | fi 8 | 9 | 10 | mkdir -p Release 11 | cd Release 12 | cmake -DCMAKE_BUILD_TYPE=Release .. 13 | make 14 | mv bin/wletdtw ../cwDTW 15 | mv bin/seq2sig ../seq2sig 16 | mv bin/sig2peak ../sig2peak 17 | cd ../ 18 | rm -rf Release 19 | 20 | 21 | -------------------------------------------------------------------------------- /lib/wavelib/src/cwtmath.h: -------------------------------------------------------------------------------- 1 | #ifndef CWTMATH_H_ 2 | #define CWTMATH_H_ 3 | 4 | #include "wtmath.h" 5 | #include "hsfft.h" 6 | 7 | #ifdef __cplusplus 8 | extern "C" { 9 | #endif 10 | 11 | void nsfft_exec(fft_object obj, fft_data *inp, fft_data *oup,double lb,double ub,double *w);// lb -lower bound, ub - upper bound, w - time or frequency grid (Size N) 12 | 13 | double gamma(double x); 14 | 15 | int nint(double N); 16 | 17 | #ifdef __cplusplus 18 | } 19 | #endif 20 | 21 | 22 | #endif /* WAVELIB_H_ */ 23 | -------------------------------------------------------------------------------- /lib/wavelib/src/wavefunc.h: -------------------------------------------------------------------------------- 1 | #ifndef WAVEFUNC_H_ 2 | #define WAVEFUNC_H_ 3 | 4 | #include "cwtmath.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | void meyer(int N,double lb,double ub,double *phi,double *psi,double *tgrid); 11 | 12 | void gauss(int N,int p,double lb,double ub,double *psi,double *t); 13 | 14 | void mexhat(int N,double lb,double ub,double *psi,double *t); 15 | 16 | void morlet(int N,double lb,double ub,double *psi,double *t); 17 | 18 | 19 | #ifdef __cplusplus 20 | } 21 | #endif 22 | 23 | 24 | #endif /* WAVEFUNC_H_ */ 25 | -------------------------------------------------------------------------------- /lib/wavelib/src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | 3 | include_directories(${CMAKE_CURRENT_SOURCE_DIR}) 4 | 5 | set(SOURCE_FILES conv.c 6 | cwt.c 7 | cwtmath.c 8 | hsfft.c 9 | real.c 10 | wavefilt.c 11 | wavefunc.c 12 | wavelib.c 13 | wtmath.c 14 | ) 15 | 16 | set(HEADER_FILES conv.h 17 | cwt.h 18 | cwtmath.h 19 | hsfft.h 20 | real.h 21 | wavefilt.h 22 | wavefunc.h 23 | wavelib.h 24 | wtmath.h 25 | ) 26 | 27 | add_library(wavelib STATIC ${SOURCE_FILES} ${HEADER_FILES}) 28 | 29 | set_property(TARGET wavelib PROPERTY FOLDER "lib") 30 | 31 | include_directories(wavelib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) 32 | 33 | -------------------------------------------------------------------------------- /lib/wavelib/src/real.h: -------------------------------------------------------------------------------- 1 | /* 2 | * real.h 3 | * 4 | * Created on: Apr 20, 2013 5 | * Author: Rafat Hussain 6 | */ 7 | 8 | #ifndef REAL_H_ 9 | #define REAL_H_ 10 | 11 | #include "hsfft.h" 12 | 13 | #ifdef __cplusplus 14 | extern "C" { 15 | #endif 16 | 17 | typedef struct fft_real_set* fft_real_object; 18 | 19 | fft_real_object fft_real_init(int N, int sgn); 20 | 21 | struct fft_real_set{ 22 | fft_object cobj; 23 | fft_data twiddle2[1]; 24 | }; 25 | 26 | void fft_r2c_exec(fft_real_object obj,fft_type *inp,fft_data *oup); 27 | 28 | void fft_c2r_exec(fft_real_object obj,fft_data *inp,fft_type *oup); 29 | 30 | void free_real_fft(fft_real_object object); 31 | 32 | #ifdef __cplusplus 33 | } 34 | #endif 35 | 36 | #endif /* REAL_H_ */ 37 | -------------------------------------------------------------------------------- /lib/wavelib/unitTests/wavelibBoostTests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | 2 | set(SOURCE_FILES 3 | tst_dwt.cpp 4 | 5 | ) 6 | 7 | 8 | 9 | 10 | 11 | add_executable(wavelibLibTests ${SOURCE_FILES} ) 12 | 13 | add_test(NAME wavelibLibTests WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/test COMMAND wavelibLibTests) 14 | 15 | add_dependencies(wavelibLibTests wavelib) 16 | target_link_libraries(wavelibLibTests wavelib) 17 | 18 | target_include_directories(wavelibLibTests PUBLIC 19 | ${CMAKE_SOURCE_DIR}/../../header 20 | ) 21 | 22 | 23 | install(TARGETS wavelibLibTests 24 | RUNTIME DESTINATION bin 25 | LIBRARY DESTINATION tests 26 | ARCHIVE DESTINATION tests 27 | ) 28 | -------------------------------------------------------------------------------- /lib/wavelib/src/cwt.h: -------------------------------------------------------------------------------- 1 | #ifndef CWT_H_ 2 | #define CWT_H_ 3 | 4 | #include "wavefunc.h" 5 | 6 | #ifdef __cplusplus 7 | extern "C" { 8 | #endif 9 | 10 | void cwavelet(const double *y, int N, double dt, int mother, double param, double s0, double dj, int jtot, int npad, 11 | double *wave, double *scale, double *period, double *coi); 12 | 13 | void psi0(int mother, double param, double *val, int *real); 14 | 15 | double factorial(int N); 16 | 17 | double cdelta(int mother, double param, double psi0); 18 | 19 | void icwavelet(double *wave, int N, double *scale, int jtot, double dt, double dj, double cdelta, double psi0, double *oup); 20 | 21 | 22 | #ifdef __cplusplus 23 | } 24 | #endif 25 | 26 | 27 | #endif /* WAVELIB_H_ */ 28 | 29 | 30 | -------------------------------------------------------------------------------- /lib/wavelib/src/wavefilt.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2014, Rafat Hussain 3 | Copyright (c) 2016, Holger Nahrstaedt 4 | */ 5 | #ifndef WAVEFILT_H_ 6 | #define WAVEFILT_H_ 7 | 8 | #include 9 | #include "conv.h" 10 | #define _USE_MATH_DEFINES 11 | #include "math.h" 12 | 13 | #ifdef __cplusplus 14 | extern "C" { 15 | #endif 16 | 17 | 18 | int filtlength(const char* name); 19 | 20 | int filtcoef(const char* name, double *lp1, double *hp1, double *lp2, double *hp2); 21 | 22 | void copy_reverse(const double *in, int N, double *out); 23 | void qmf_even(const double *in, int N, double *out); 24 | void qmf_wrev(const double *in, int N, double *out); 25 | void copy(const double *in, int N, double *out); 26 | #ifdef __cplusplus 27 | } 28 | #endif 29 | 30 | 31 | #endif /* WAVEFILT_H_ */ -------------------------------------------------------------------------------- /lib/wavelib/src/wtmath.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2014, Rafat Hussain 3 | */ 4 | #ifndef WTMATH_H_ 5 | #define WTMATH_H_ 6 | 7 | #include "wavefilt.h" 8 | 9 | #ifdef __cplusplus 10 | extern "C" { 11 | #endif 12 | 13 | int upsamp(double *x, int lenx, int M, double *y); 14 | 15 | int upsamp2(double *x, int lenx, int M, double *y); 16 | 17 | int downsamp(double *x, int lenx, int M, double *y); 18 | 19 | int per_ext(double *sig, int len, int a,double *oup); 20 | 21 | int symm_ext(double *sig, int len, int a,double *oup); 22 | 23 | void circshift(double *array, int N, int L); 24 | 25 | int testSWTlength(int N, int J); 26 | 27 | int wmaxiter(int sig_len, int filt_len); 28 | 29 | double costfunc(double *x, int N, char *entropy, double p); 30 | 31 | #ifdef __cplusplus 32 | } 33 | #endif 34 | 35 | 36 | #endif /* WAVELIB_H_ */ 37 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | project(wletdtw) 2 | 3 | cmake_minimum_required(VERSION 2.8) 4 | 5 | include(CheckCXXCompilerFlag) 6 | CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11) 7 | CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X) 8 | if(COMPILER_SUPPORTS_CXX11) 9 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11") 10 | elseif(COMPILER_SUPPORTS_CXX0X) 11 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x") 12 | else() 13 | message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no 14 | C++11 support. Please use a different C++ compiler.") 15 | endif() 16 | 17 | set(WAVELET_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/lib/wavelib/header) 18 | 19 | include_directories(${PROJECT_SOURCE_DIR}/lib ${PROJECT_SOURCE_DIR}/src ${WAVELET_INCLUDE_DIR}) 20 | link_directories (${PROJECT_BINARY_DIR}/lib) 21 | 22 | set(EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/bin) 23 | set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib) 24 | 25 | add_subdirectory(lib) 26 | add_subdirectory(src) 27 | -------------------------------------------------------------------------------- /src/proc/io.h: -------------------------------------------------------------------------------- 1 | #ifndef IO_H__ 2 | #define IO_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | namespace g{ 12 | namespace io{ 13 | 14 | bool ReadATCG(const char* name, std::vector& genomes); 15 | 16 | bool WriteATCG(const char* name, const std::vector& genomes); 17 | 18 | bool ReadSignalSequence(const char* name, std::vector& signals); 19 | 20 | bool ReadSignalSequence_int(const char* name, std::vector& signals); 21 | 22 | bool WriteSignalSequence(const char* name, const std::vector& signals); 23 | 24 | bool WriteSignalSequence_int(const char* name, const std::vector& signals); 25 | 26 | //---- write signal with name ----// 27 | bool WriteSignalSequence_withName(const char* name, 28 | const std::vector& signals, 29 | const std::vector& kmer_rec); 30 | bool WriteSignalSequence_int_withName(const char* name, 31 | const std::vector& signals, 32 | const std::vector& kmer_rec); 33 | 34 | } 35 | 36 | } 37 | 38 | #endif 39 | -------------------------------------------------------------------------------- /lib/wavelib/test/wtreetest.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "../header/wavelib.h" 6 | 7 | int main() { 8 | int i, J, N, len; 9 | int X, Y; 10 | wave_object obj; 11 | wtree_object wt; 12 | double *inp, *oup; 13 | 14 | char *name = "db3"; 15 | obj = wave_init(name);// Initialize the wavelet 16 | N = 147; 17 | inp = (double*)malloc(sizeof(double)* N); 18 | for (i = 1; i < N + 1; ++i) { 19 | inp[i - 1] = -0.25*i*i*i + 25 * i *i + 10 * i; 20 | } 21 | J = 3; 22 | 23 | wt = wtree_init(obj, N, J);// Initialize the wavelet transform object 24 | setWTREEExtension(wt, "sym");// Options are "per" and "sym". Symmetric is the default option 25 | 26 | wtree(wt, inp); 27 | wtree_summary(wt); 28 | X = 3; 29 | Y = 5; 30 | len = getWTREENodelength(wt, X); 31 | printf("\n %d", len); 32 | printf("\n"); 33 | oup = (double*)malloc(sizeof(double)* len); 34 | 35 | printf("Node [%d %d] Coefficients : \n",X,Y); 36 | getWTREECoeffs(wt, X, Y, oup, len); 37 | for (i = 0; i < len; ++i) { 38 | printf("%g ", oup[i]); 39 | } 40 | printf("\n"); 41 | 42 | free(inp); 43 | free(oup); 44 | wave_free(obj); 45 | wtree_free(wt); 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /src/proc/cwdtw.h: -------------------------------------------------------------------------------- 1 | #ifndef CWDTW_H__ 2 | #define CWDTW_H__ 3 | 4 | #include "io.h" 5 | #include "proc.h" 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include "wavelib.h" 12 | 13 | using namespace std; 14 | 15 | namespace g{ 16 | namespace cwdtw{ 17 | 18 | void CWTAnalysis( 19 | const std::vector& raw, 20 | std::vector >& output, 21 | double scale0, double dscale, long npyr); 22 | 23 | void BoundGeneration( 24 | std::vector >& cosali, 25 | long neib, std::vector >& bound, int mode, 26 | int RENMIN_or_SHENG=0); 27 | 28 | void FastDTW( 29 | std::vector& in1, std::vector& in2, 30 | std::vector >& alignment, 31 | long radius, long max_level, int mode, 32 | double* totaldiff = 0); 33 | 34 | void MultiLevel_WaveletDTW( 35 | std::vector& in1, std::vector& in2, 36 | std::vector >& sig1, 37 | std::vector >& sig2, 38 | std::vector >& alignment, 39 | long radius, int test, int mode, 40 | double* totaldiff = 0); 41 | 42 | } 43 | 44 | } 45 | 46 | 47 | #endif 48 | 49 | -------------------------------------------------------------------------------- /lib/wavelib/src/conv.h: -------------------------------------------------------------------------------- 1 | /* 2 | * conv.h 3 | * 4 | * Created on: May 1, 2013 5 | * Author: Rafat Hussain 6 | */ 7 | 8 | #ifndef CONV_H_ 9 | #define CONV_H_ 10 | 11 | #include "real.h" 12 | 13 | #ifdef __cplusplus 14 | extern "C" { 15 | #endif 16 | 17 | #define MIN(a,b) (((a)<(b))?(a):(b)) 18 | #define MAX(a,b) (((a)>(b))?(a):(b)) 19 | 20 | typedef struct conv_set* conv_object; 21 | 22 | conv_object conv_init(int N, int L); 23 | 24 | struct conv_set{ 25 | fft_real_object fobj; 26 | fft_real_object iobj; 27 | int ilen1; 28 | int ilen2; 29 | int clen; 30 | }; 31 | 32 | int factorf(int M); 33 | 34 | int findnext(int M); 35 | 36 | int findnexte(int M); 37 | 38 | void conv_direct(fft_type *inp1,int N, fft_type *inp2, int L,fft_type *oup); 39 | 40 | void conv_directx(fft_type *inp1,int N, fft_type *inp2, int L,fft_type *oup); 41 | 42 | //void conv_fft(const conv_object obj,fft_type *inp1,fft_type *inp2,fft_type *oup); 43 | 44 | //void conv_fft(const conv_object obj,fft_type *inp1,fft_type *inp2,fft_type *oup); 45 | 46 | void conv_fft(const conv_object obj,fft_type *inp1,fft_type *inp2,fft_type *oup); 47 | 48 | //void free_conv(conv_object object); 49 | 50 | void free_conv(conv_object object); 51 | 52 | 53 | #ifdef __cplusplus 54 | } 55 | #endif 56 | 57 | #endif /* CONV_H_ */ 58 | -------------------------------------------------------------------------------- /lib/wavelib/src/hsfft.h: -------------------------------------------------------------------------------- 1 | /* 2 | * hsfft.h 3 | * 4 | * Created on: Apr 14, 2013 5 | * Author: Rafat Hussain 6 | */ 7 | 8 | #ifndef HSFFT_H_ 9 | #define HSFFT_H_ 10 | 11 | #include 12 | #include 13 | #include 14 | 15 | #ifdef __cplusplus 16 | extern "C" { 17 | #endif 18 | 19 | #define PI2 6.28318530717958647692528676655900577 20 | 21 | #ifndef fft_type 22 | #define fft_type double 23 | #endif 24 | 25 | 26 | typedef struct fft_t { 27 | fft_type re; 28 | fft_type im; 29 | } fft_data; 30 | /* 31 | #define SADD(a,b) ((a)+(b)) 32 | 33 | #define SSUB(a,b) ((a)+(b)) 34 | 35 | #define SMUL(a,b) ((a)*(b)) 36 | */ 37 | 38 | typedef struct fft_set* fft_object; 39 | 40 | fft_object fft_init(int N, int sgn); 41 | 42 | struct fft_set{ 43 | int N; 44 | int sgn; 45 | int factors[64]; 46 | int lf; 47 | int lt; 48 | fft_data twiddle[1]; 49 | }; 50 | 51 | void fft_exec(fft_object obj,fft_data *inp,fft_data *oup); 52 | 53 | int divideby(int M,int d); 54 | 55 | int dividebyN(int N); 56 | 57 | //void arrrev(int M, int* arr); 58 | 59 | int factors(int M, int* arr); 60 | 61 | void twiddle(fft_data *sig,int N, int radix); 62 | 63 | void longvectorN(fft_data *sig,int N, int *array, int M); 64 | 65 | void free_fft(fft_object object); 66 | 67 | #ifdef __cplusplus 68 | } 69 | #endif 70 | 71 | 72 | 73 | 74 | #endif /* HSFFT_H_ */ 75 | -------------------------------------------------------------------------------- /lib/wavelib/test/dwpttest.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "../header/wavelib.h" 6 | 7 | double absmax(double *array, int N) { 8 | double max; 9 | int i; 10 | 11 | max = 0.0; 12 | for (i = 0; i < N; ++i) { 13 | if (fabs(array[i]) >= max) { 14 | max = fabs(array[i]); 15 | } 16 | } 17 | 18 | return max; 19 | } 20 | 21 | int main() { 22 | int i, J, N; 23 | wave_object obj; 24 | wpt_object wt; 25 | double *inp, *oup, *diff; 26 | 27 | char *name = "db4"; 28 | obj = wave_init(name);// Initialize the wavelet 29 | N = 788 + 23; 30 | inp = (double*)malloc(sizeof(double)* N); 31 | oup = (double*)malloc(sizeof(double)* N); 32 | diff = (double*)malloc(sizeof(double)* N); 33 | for (i = 1; i < N + 1; ++i) { 34 | //inp[i - 1] = -0.25*i*i*i + 25 * i *i + 10 * i; 35 | inp[i - 1] = i; 36 | } 37 | J = 4; 38 | 39 | wt = wpt_init(obj, N, J);// Initialize the wavelet transform Tree object 40 | setDWPTExtension(wt, "per");// Options are "per" and "sym". Symmetric is the default option 41 | setDWPTEntropy(wt, "logenergy", 0); 42 | 43 | dwpt(wt, inp); // Discrete Wavelet Packet Transform 44 | 45 | idwpt(wt, oup); // Inverse Discrete Wavelet Packet Transform 46 | 47 | for (i = 0; i < N; ++i) { 48 | diff[i] = (inp[i] - oup[i])/inp[i]; 49 | } 50 | 51 | wpt_summary(wt); // Tree Summary 52 | 53 | printf("\n MAX %g \n", absmax(diff, wt->siglength)); // If Reconstruction succeeded then the output should be a small value. 54 | 55 | free(inp); 56 | free(oup); 57 | free(diff); 58 | wave_free(obj); 59 | wpt_free(wt); 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /src/util/qsort.h: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2008 Noah Snavely (snavely (at) cs.washington.edu) 3 | * and the University of Washington 4 | * 5 | * This program is free software; you can redistribute it and/or modify 6 | * it under the terms of the GNU General Public License as published by 7 | * the Free Software Foundation; either version 2 of the License, or 8 | * (at your option) any later version. 9 | * 10 | * This program is distributed in the hope that it will be useful, 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | * GNU General Public License for more details. 14 | * 15 | */ 16 | 17 | #ifndef __qsort_h__ 18 | #define __qsort_h__ 19 | 20 | 21 | /* Set whether we should sort in ascending or descending order */ 22 | void qsort_ascending(); 23 | void qsort_descending(); 24 | 25 | /* Sorts the array of doubles `arr' (of length n) and puts the 26 | * corresponding permutation in `perm' */ 27 | void qsort_perm(int n, double *arr, int *perm); 28 | 29 | /* Permute the array `arr' given permutation `perm' */ 30 | void permute_dbl(int n, double *arr, int *perm); 31 | void permute(int n, int size, void *arr, int *perm); 32 | 33 | /* Find the median in a set of doubles */ 34 | double median(int n, double *arr); 35 | double median_copy(int n, double *arr); 36 | 37 | /* Find the kth element in an unordered list of doubles (changes the 38 | * array) */ 39 | double kth_element(int n, int k, double *arr); 40 | /* Same as above, doesn't change the array */ 41 | double kth_element_copy(int n, int k, double *arr); 42 | 43 | #endif /* __qsort_h__ */ 44 | -------------------------------------------------------------------------------- /src/kmer/kmer_index.h: -------------------------------------------------------------------------------- 1 | #ifndef FIVEMER_INDEX_H__ 2 | #define FIVEMER_INDEX_H__ 3 | 4 | #include 5 | #include 6 | 7 | namespace g{ 8 | 9 | class Mer2Signal 10 | { 11 | private: 12 | //---- in-house made 5-mer pore model ----// 13 | /* avg, var, len, #, #, #, # (defined in 5mer_index_table.rc) */ 14 | //const static double index_table_self[1024][6]; //-> (obsoleted) 15 | 16 | //---- official 5/6-mer pore model ------// 17 | //-> download from 'https://github.com/nanoporetech/kmer_models/tree/master/r9.4_180mv_450bps_6mer' 18 | const static double index_table_5mer[1024]; 19 | const static double index_table_6mer[4096]; 20 | //-> download from: 21 | // 'https://github.com/nanoporetech/kmer_models/blob/master/r9.4_200mv_70bps_5mer_RNA/template_median68pA.model' 22 | // 'https://github.com/nanoporetech/kmer_models/blob/master/r9.4_180mv_70bps_5mer_RNA/template_median69pA.model' 23 | const static double rna_table_5mer[1024][2]; 24 | 25 | public: 26 | //----- Nucleotide_to_Int ---// 27 | static int Nucleotide_to_Int(char c); 28 | 29 | //----- generate index -------// 30 | static void Genome2Index_5mer(const std::vector &input, std::vector &index); 31 | static void Genome2Index_6mer(const std::vector &input, std::vector &index); 32 | 33 | //----- extract content -----// 34 | //static double AvgSignalAt_SelfModel(int index); //-> (obsoleted) 35 | static double AvgSignalAt_5mer(int index); 36 | static double AvgSignalAt_6mer(int index); 37 | //-> RNA 38 | static double RnaSignalAt_5mer_200mv(int index); 39 | static double RnaSignalAt_5mer_180mv(int index); 40 | }; 41 | 42 | } 43 | 44 | #endif 45 | 46 | -------------------------------------------------------------------------------- /lib/wavelib/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 2.8.0 FATAL_ERROR) 2 | 3 | set(PROJECT_NAME wavelib) 4 | project(${PROJECT_NAME} CXX C) 5 | 6 | 7 | # src root path 8 | set(WAVELIB_SRC_ROOT ${PROJECT_SOURCE_DIR} CACHE PATH "Wavelib source root") 9 | # binary output by default 10 | # set(COMMON_BIN_PATH ${CMAKE_BINARY_DIR}/Bin) 11 | # set(LIBRARY_OUTPUT_PATH ${COMMON_BIN_PATH}/${CMAKE_BUILD_TYPE}) 12 | # set(EXECUTABLE_OUTPUT_PATH ${COMMON_BIN_PATH}/${CMAKE_BUILD_TYPE}) 13 | # set where to find additional cmake modules if any 14 | set(CMAKE_MODULE_PATH ${WAVELIB_SRC_ROOT}/cmake ${CMAKE_MODULE_PATH}) 15 | 16 | 17 | set(WAVELIB_VERSION "1.0.0" CACHE STRING "Wavelib version" FORCE) 18 | # message(">>> Building Wavelib version: ${WAVELIB_VERSION}") 19 | # message(">>> EXECUTABLE_OUTPUT_PATH = ${EXECUTABLE_OUTPUT_PATH}") 20 | 21 | option(BUILD_UT "Enable Unit test" OFF) 22 | 23 | # cleanup prefix lib for Unix-like OSes 24 | set(CMAKE_SHARED_MODULE_PREFIX) 25 | 26 | # install target to this folder by default 27 | set(WAVELIB_BINARY_DIR ${WAVELIB_SRC_ROOT}/bin) 28 | if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) 29 | set(CMAKE_INSTALL_PREFIX "${WAVELIB_BINARY_DIR}" CACHE PATH "default install path" FORCE) 30 | endif() 31 | 32 | # make include globaly visible 33 | set(PROJECT_WIDE_INCLUDE ${WAVELIB_SRC_ROOT}/include) 34 | include_directories(${PROJECT_WIDE_INCLUDE}) 35 | 36 | 37 | 38 | 39 | include_directories(${COMMON_BIN_PATH}) 40 | 41 | if(BUILD_UT) 42 | include(CTest) 43 | enable_testing() 44 | add_subdirectory(unitTests) 45 | endif() 46 | 47 | add_subdirectory(src) 48 | 49 | #install(DIRECTORY ${WAVELIB_SRC_ROOT}/include/ DESTINATION include FILES_MATCHING PATTERN "*.h") 50 | -------------------------------------------------------------------------------- /lib/wavelib/test/modwttest.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "../header/wavelib.h" 6 | 7 | double absmax(double *array, int N) { 8 | double max; 9 | int i; 10 | 11 | max = 0.0; 12 | for (i = 0; i < N; ++i) { 13 | if (fabs(array[i]) >= max) { 14 | max = fabs(array[i]); 15 | } 16 | } 17 | 18 | return max; 19 | } 20 | 21 | int main() { 22 | wave_object obj; 23 | wt_object wt; 24 | double *inp, *out, *diff; 25 | int N, i, J; 26 | 27 | FILE *ifp; 28 | double temp[1200]; 29 | 30 | char *name = "db4"; 31 | obj = wave_init(name); 32 | wave_summary(obj); 33 | 34 | ifp = fopen("signal.txt", "r"); 35 | i = 0; 36 | if (!ifp) { 37 | printf("Cannot Open File"); 38 | exit(100); 39 | } 40 | while (!feof(ifp)) { 41 | fscanf(ifp, "%lf \n", &temp[i]); 42 | i++; 43 | } 44 | N = 177; 45 | 46 | inp = (double*)malloc(sizeof(double)* N); 47 | out = (double*)malloc(sizeof(double)* N); 48 | diff = (double*)malloc(sizeof(double)* N); 49 | //wmean = mean(temp, N); 50 | 51 | for (i = 0; i < N; ++i) { 52 | inp[i] = temp[i]; 53 | //printf("%g \n",inp[i]); 54 | } 55 | J = 2; 56 | 57 | wt = wt_init(obj, "modwt", N, J);// Initialize the wavelet transform object 58 | 59 | modwt(wt, inp);// Perform MODWT 60 | //MODWT output can be accessed using wt->output vector. Use wt_summary to find out how to extract appx and detail coefficients 61 | 62 | for (i = 0; i < wt->outlength; ++i) { 63 | printf("%g ",wt->output[i]); 64 | } 65 | 66 | imodwt(wt, out);// Perform ISWT (if needed) 67 | // Test Reconstruction 68 | 69 | 70 | for (i = 0; i < wt->siglength; ++i) { 71 | diff[i] = out[i] - inp[i]; 72 | } 73 | 74 | printf("\n MAX %g \n", absmax(diff, wt->siglength));// If Reconstruction succeeded then the output should be a small value. 75 | 76 | wt_summary(wt);// Prints the full summary. 77 | 78 | wave_free(obj); 79 | wt_free(wt); 80 | 81 | free(inp); 82 | free(out); 83 | free(diff); 84 | return 0; 85 | } 86 | 87 | -------------------------------------------------------------------------------- /lib/wavelib/test/swttest.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "../header/wavelib.h" 6 | 7 | double absmax(double *array, int N) { 8 | double max; 9 | int i; 10 | 11 | max = 0.0; 12 | for (i = 0; i < N; ++i) { 13 | if (fabs(array[i]) >= max) { 14 | max = fabs(array[i]); 15 | } 16 | } 17 | 18 | return max; 19 | } 20 | 21 | int main() { 22 | wave_object obj; 23 | wt_object wt; 24 | double *inp, *out, *diff; 25 | int N, i, J; 26 | 27 | FILE *ifp; 28 | double temp[1200]; 29 | 30 | char *name = "bior3.5"; 31 | obj = wave_init(name);// Initialize the wavelet 32 | 33 | ifp = fopen("signal.txt", "r"); 34 | i = 0; 35 | if (!ifp) { 36 | printf("Cannot Open File"); 37 | exit(100); 38 | } 39 | while (!feof(ifp)) { 40 | fscanf(ifp, "%lf \n", &temp[i]); 41 | i++; 42 | } 43 | N = 256; 44 | 45 | inp = (double*)malloc(sizeof(double)* N); 46 | out = (double*)malloc(sizeof(double)* N); 47 | diff = (double*)malloc(sizeof(double)* N); 48 | //wmean = mean(temp, N); 49 | 50 | for (i = 0; i < N; ++i) { 51 | inp[i] = temp[i]; 52 | //printf("%g \n",inp[i]); 53 | } 54 | J = 1; 55 | 56 | wt = wt_init(obj, "swt", N, J);// Initialize the wavelet transform object 57 | setWTConv(wt, "direct"); 58 | 59 | 60 | swt(wt, inp);// Perform SWT 61 | //SWT output can be accessed using wt->output vector. Use wt_summary to find out how to extract appx and detail coefficients 62 | 63 | for (i = 0; i < wt->outlength; ++i) { 64 | printf("%g ",wt->output[i]); 65 | } 66 | 67 | iswt(wt, out);// Perform ISWT (if needed) 68 | // Test Reconstruction 69 | 70 | 71 | for (i = 0; i < wt->siglength; ++i) { 72 | diff[i] = out[i] - inp[i]; 73 | } 74 | 75 | printf("\n MAX %g \n", absmax(diff, wt->siglength));// If Reconstruction succeeded then the output should be a small value. 76 | 77 | wt_summary(wt);// Prints the full summary. 78 | 79 | 80 | wave_free(obj); 81 | wt_free(wt); 82 | 83 | free(inp); 84 | free(out); 85 | free(diff); 86 | return 0; 87 | } 88 | -------------------------------------------------------------------------------- /lib/wavelib/test/dwttest.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "../header/wavelib.h" 6 | 7 | double absmax(double *array, int N) { 8 | double max; 9 | int i; 10 | 11 | max = 0.0; 12 | for (i = 0; i < N; ++i) { 13 | if (fabs(array[i]) >= max) { 14 | max = fabs(array[i]); 15 | } 16 | } 17 | 18 | return max; 19 | } 20 | 21 | int main() { 22 | wave_object obj; 23 | wt_object wt; 24 | double *inp,*out,*diff; 25 | int N, i,J; 26 | 27 | FILE *ifp; 28 | double temp[1200]; 29 | 30 | char *name = "db4"; 31 | obj = wave_init(name);// Initialize the wavelet 32 | 33 | ifp = fopen("signal.txt", "r"); 34 | i = 0; 35 | if (!ifp) { 36 | printf("Cannot Open File"); 37 | exit(100); 38 | } 39 | while (!feof(ifp)) { 40 | fscanf(ifp, "%lf \n", &temp[i]); 41 | i++; 42 | } 43 | N = 256; 44 | 45 | inp = (double*)malloc(sizeof(double)* N); 46 | out = (double*)malloc(sizeof(double)* N); 47 | diff = (double*)malloc(sizeof(double)* N); 48 | //wmean = mean(temp, N); 49 | 50 | for (i = 0; i < N; ++i) { 51 | inp[i] = temp[i]; 52 | //printf("%g \n",inp[i]); 53 | } 54 | J = 3; 55 | 56 | wt = wt_init(obj, "dwt", N, J);// Initialize the wavelet transform object 57 | setDWTExtension(wt, "sym");// Options are "per" and "sym". Symmetric is the default option 58 | setWTConv(wt, "direct"); 59 | 60 | dwt(wt, inp);// Perform DWT 61 | //DWT output can be accessed using wt->output vector. Use wt_summary to find out how to extract appx and detail coefficients 62 | 63 | for (i = 0; i < wt->outlength; ++i) { 64 | printf("%g ",wt->output[i]); 65 | } 66 | 67 | idwt(wt, out);// Perform IDWT (if needed) 68 | // Test Reconstruction 69 | for (i = 0; i < wt->siglength; ++i) { 70 | diff[i] = out[i] - inp[i]; 71 | } 72 | 73 | printf("\n MAX %g \n", absmax(diff, wt->siglength)); // If Reconstruction succeeded then the output should be a small value. 74 | 75 | wt_summary(wt);// Prints the full summary. 76 | wave_free(obj); 77 | wt_free(wt); 78 | 79 | free(inp); 80 | free(out); 81 | free(diff); 82 | return 0; 83 | } 84 | -------------------------------------------------------------------------------- /lib/wavelib/test/signal.txt: -------------------------------------------------------------------------------- 1 | -18.3237 -18.2232 -18.0974 -17.9410 -17.7480 -17.5113 -17.2230 -16.8744 -16.4558 -15.9565 -15.3653 -14.6701 -13.8586 -12.9182 -11.8363 -10.6008 -9.2006 -7.6257 -5.8680 -3.9217 -1.7839 0.5452 3.0614 5.7562 8.6167 11.6252 14.7591 17.9909 21.2884 24.6155 27.9319 31.1947 34.3587 37.3775 40.2049 42.7957 13.2164 14.2125 15.0317 15.6595 16.0845 16.2990 16.2990 16.0845 15.6595 15.0317 14.2125 13.2164 12.0608 10.7654 9.3517 34.3587 31.1947 27.9319 24.6155 21.2884 17.9909 14.7591 11.6252 8.6167 5.7562 3.0614 0.5452 -1.7839 -3.9217 -5.8680 -7.6257 -9.2006 -10.6008 -11.8363 -12.9182 -13.8586 -14.6701 -15.3653 -15.9565 -16.4558 -16.8744 -17.2230 -17.5113 -17.7480 -17.9410 -18.0974 -18.2232 -18.3237 -18.4035 -18.0080 -17.8889 -17.7403 -17.5533 -17.3156 -17.0102 -16.6129 -16.0884 -15.3848 -14.4239 -13.0840 -11.1708 -8.3634 -4.1098 2.5833 13.6048 32.7934 28.0187 10.9660 1.0776 -4.9459 -8.7354 -11.1225 -12.4865 -12.8019 -11.2050 -3.3124 1.8995 -11.3573 -15.0684 -16.5028 -17.1937 -17.5831 -17.8288 -17.9968 -18.1185 -18.2103 -18.2818 -18.3388 -18.3849 -18.4229 -18.4545 -18.4810 -17.4642 -17.2104 -16.9033 -16.5317 -16.0822 -15.5384 -14.8804 -14.0844 -13.1214 -11.9563 -10.5467 -8.8414 -6.7782 -4.2822 -1.2624 2.3911 6.8111 12.1585 18.6280 26.4549 35.9241 35.9241 26.4549 18.6280 12.1585 6.8111 2.3911 -1.2624 -4.2822 -6.7782 -8.8414 -10.5467 -11.9563 -13.1214 -14.0844 -14.8804 -15.5384 -16.0822 -16.5317 -16.9033 -17.2104 -17.4642 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 6.3259 34.8066 34.6752 34.5285 34.3645 34.1812 33.9763 33.7474 33.4917 33.2058 32.8863 32.5294 32.1304 31.6846 31.1864 30.6296 30.0074 29.3121 28.5350 27.6667 26.6963 25.6118 24.3999 23.0456 21.5322 19.8408 17.9507 15.8385 13.4781 10.8403 7.8925 4.5982 0.9168 -3.1972 -7.7947 -12.9325 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.6741 -18.3237 -------------------------------------------------------------------------------- /lib/wavelib/test/cwttest.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "../header/wavelib.h" 6 | 7 | int main() { 8 | int i, N, J,subscale,a0,iter,nd,k; 9 | double *inp,*oup; 10 | double dt, dj,s0, param,mn; 11 | double td,tn,den, num, recon_mean, recon_var; 12 | cwt_object wt; 13 | 14 | FILE *ifp; 15 | double temp[1200]; 16 | 17 | char *wave = "morlet";// Set Morlet wavelet. Other options "paul" and "dog" 18 | char *type = "pow"; 19 | 20 | N = 504; 21 | param = 6.0; 22 | subscale = 4; 23 | dt = 0.25; 24 | s0 = dt; 25 | dj = 1.0 / (double)subscale; 26 | J = 11 * subscale; // Total Number of scales 27 | a0 = 2;//power 28 | 29 | ifp = fopen("sst_nino3.dat", "r"); 30 | i = 0; 31 | if (!ifp) { 32 | printf("Cannot Open File"); 33 | exit(100); 34 | } 35 | while (!feof(ifp)) { 36 | fscanf(ifp, "%lf \n", &temp[i]); 37 | i++; 38 | } 39 | 40 | fclose(ifp); 41 | 42 | wt = cwt_init(wave, param, N,dt, J); 43 | 44 | inp = (double*)malloc(sizeof(double)* N); 45 | oup = (double*)malloc(sizeof(double)* N); 46 | 47 | for (i = 0; i < N; ++i) { 48 | inp[i] = temp[i] ; 49 | } 50 | 51 | setCWTScales(wt, s0, dj, type, a0); 52 | 53 | cwt(wt, inp); 54 | 55 | printf("\n MEAN %g \n", wt->smean); 56 | 57 | mn = 0.0; 58 | 59 | for (i = 0; i < N; ++i) { 60 | mn += sqrt(wt->output[i].re * wt->output[i].re + wt->output[i].im * wt->output[i].im); 61 | } 62 | 63 | cwt_summary(wt); 64 | 65 | printf("\n abs mean %g \n", mn / N); 66 | 67 | printf("\n\n"); 68 | printf("Let CWT w = w(j, n/2 - 1) where n = %d\n\n", N); 69 | nd = N/2 - 1; 70 | 71 | printf("%-15s%-15s%-15s%-15s \n","j","Scale","Period","ABS(w)^2"); 72 | for(k = 0; k < wt->J;++k) { 73 | iter = nd + k * N; 74 | printf("%-15d%-15lf%-15lf%-15lf \n",k,wt->scale[k],wt->period[k], 75 | wt->output[iter].re * wt->output[iter].re + wt->output[iter].im * wt->output[iter].im); 76 | } 77 | 78 | icwt(wt, oup); 79 | 80 | num = den = recon_var = recon_mean = 0.0; 81 | printf("\n\n"); 82 | printf("Signal Reconstruction\n"); 83 | printf("%-15s%-15s%-15s \n","i","Input(i)","Output(i)"); 84 | 85 | for (i = N - 10; i < N; ++i) { 86 | printf("%-15d%-15lf%-15lf \n", i,inp[i] , oup[i]); 87 | } 88 | 89 | for (i = 0; i < N; ++i) { 90 | //printf("%g %g \n", oup[i] ,inp[i] - wt->smean); 91 | td = inp[i] ; 92 | tn = oup[i] - td; 93 | num += (tn * tn); 94 | den += (td * td); 95 | recon_mean += oup[i]; 96 | } 97 | 98 | recon_var = sqrt(num / N); 99 | recon_mean /= N; 100 | 101 | printf("\nRMS Error %g \n", sqrt(num) / sqrt(den)); 102 | printf("\nVariance %g \n", recon_var); 103 | printf("\nMean %g \n", recon_mean); 104 | 105 | free(inp); 106 | free(oup); 107 | cwt_free(wt); 108 | return 0; 109 | } 110 | -------------------------------------------------------------------------------- /src/kmer/kmer_index.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "kmer_index.h" 3 | #include "5mer_index_official.rc" 4 | #include "6mer_index_official.rc" 5 | #include "rna_inddx_official.rc" 6 | 7 | 8 | //---------- Nucleotide_to_Int ----------// 9 | /* A = 0; C = 1; G = 2; T = 3 */ 10 | int g::Mer2Signal::Nucleotide_to_Int(char c) 11 | { 12 | int tag; 13 | switch(c) 14 | { 15 | case 'A': 16 | tag = 0; 17 | break; 18 | case 'C': 19 | tag = 1; 20 | break; 21 | case 'G': 22 | tag = 2; 23 | break; 24 | case 'T': 25 | tag = 3; 26 | break; 27 | case 'U': 28 | tag = 3; //-> for RNA only 29 | break; 30 | default: 31 | fprintf(stderr,"BAD CODE HERE !! %c \n",c); 32 | exit(-1); 33 | } 34 | return tag; 35 | } 36 | 37 | 38 | //------------ given genome, transfer to 5-mer index ---------------// 39 | void g::Mer2Signal::Genome2Index_5mer(const std::vector &input, std::vector &index) 40 | { 41 | int div=256; 42 | size_t size=input.size(); 43 | index.assign(size,-1); 44 | 45 | short idx = 0; 46 | for(int i = 0; i < 5; i++) 47 | { 48 | short tag=Nucleotide_to_Int(input[i]); 49 | tag <<= (4-i)*2; 50 | idx |= tag; 51 | } 52 | index[0]=idx; 53 | 54 | 55 | for(size_t i=5;i &input, std::vector &index) 66 | { 67 | int div=1024; 68 | size_t size=input.size(); 69 | index.assign(size,-1); 70 | 71 | short idx = 0; 72 | for(int i = 0; i < 6; i++) 73 | { 74 | short tag=Nucleotide_to_Int(input[i]); 75 | tag <<= (5-i)*2; 76 | idx |= tag; 77 | } 78 | index[0]=idx; 79 | 80 | 81 | for(size_t i=6;i self_model is based on 5mer pore model (obsoleted) 92 | /* 93 | double g::Mer2Signal::AvgSignalAt_SelfModel(int index) 94 | { 95 | return index_table_self[index][0]; 96 | } 97 | */ 98 | 99 | //-> 5mer case 100 | double g::Mer2Signal::AvgSignalAt_5mer(int index) 101 | { 102 | return index_table_5mer[index]; 103 | } 104 | 105 | //-> 6mer case 106 | double g::Mer2Signal::AvgSignalAt_6mer(int index) 107 | { 108 | return index_table_6mer[index]; 109 | } 110 | 111 | //---------- RNA case ------------// 112 | //-> 200mv RNA 113 | double g::Mer2Signal::RnaSignalAt_5mer_200mv(int index) 114 | { 115 | return rna_table_5mer[index][0]; 116 | } 117 | 118 | //-> 180mv RNA 119 | double g::Mer2Signal::RnaSignalAt_5mer_180mv(int index) 120 | { 121 | return rna_table_5mer[index][1]; 122 | } 123 | 124 | -------------------------------------------------------------------------------- /lib/wavelib/src/real.c: -------------------------------------------------------------------------------- 1 | /* 2 | * real.c 3 | * 4 | * Created on: Apr 20, 2013 5 | * Author: Rafat Hussain 6 | */ 7 | #include 8 | #include "real.h" 9 | 10 | fft_real_object fft_real_init(int N, int sgn) { 11 | fft_real_object obj = NULL; 12 | fft_type PI, theta; 13 | int k; 14 | 15 | PI = 3.1415926535897932384626433832795; 16 | 17 | obj = (fft_real_object) malloc (sizeof(struct fft_real_set) + sizeof(fft_data)* (N/2)); 18 | 19 | obj->cobj = fft_init(N/2,sgn); 20 | 21 | for (k = 0; k < N/2;++k) { 22 | theta = PI2*k/N; 23 | obj->twiddle2[k].re = cos(theta); 24 | obj->twiddle2[k].im = sin(theta); 25 | 26 | } 27 | 28 | 29 | return obj; 30 | 31 | 32 | } 33 | 34 | void fft_r2c_exec(fft_real_object obj,fft_type *inp,fft_data *oup) { 35 | fft_data* cinp; 36 | fft_data* coup; 37 | int i,N2,N; 38 | fft_type temp1,temp2; 39 | N2 = obj->cobj->N; 40 | N = N2*2; 41 | 42 | cinp = (fft_data*) malloc (sizeof(fft_data) * N2); 43 | coup = (fft_data*) malloc (sizeof(fft_data) * N2); 44 | 45 | for (i = 0; i < N2; ++i) { 46 | cinp[i].re = inp[2*i]; 47 | cinp[i].im = inp[2*i+1]; 48 | } 49 | 50 | fft_exec(obj->cobj,cinp,coup); 51 | 52 | oup[0].re = coup[0].re + coup[0].im; 53 | oup[0].im = 0.0; 54 | 55 | for (i = 1; i < N2; ++i) { 56 | temp1 = coup[i].im + coup[N2-i].im ; 57 | temp2 = coup[N2-i].re - coup[i].re ; 58 | oup[i].re = (coup[i].re + coup[N2-i].re + (temp1 * obj->twiddle2[i].re) + (temp2 * obj->twiddle2[i].im)) / 2.0; 59 | oup[i].im = (coup[i].im - coup[N2-i].im + (temp2 * obj->twiddle2[i].re) - (temp1 * obj->twiddle2[i].im)) / 2.0; 60 | } 61 | 62 | 63 | 64 | oup[N2].re = coup[0].re - coup[0].im; 65 | oup[N2].im = 0.0; 66 | 67 | for (i = 1; i < N2;++i) { 68 | oup[N-i].re = oup[i].re; 69 | oup[N-i].im = -oup[i].im; 70 | } 71 | 72 | 73 | free(cinp); 74 | free(coup); 75 | 76 | } 77 | 78 | void fft_c2r_exec(fft_real_object obj,fft_data *inp,fft_type *oup) { 79 | 80 | fft_data* cinp; 81 | fft_data* coup; 82 | int i,N2,N; 83 | fft_type temp1,temp2; 84 | N2 = obj->cobj->N; 85 | N = N2*2; 86 | 87 | cinp = (fft_data*) malloc (sizeof(fft_data) * N2); 88 | coup = (fft_data*) malloc (sizeof(fft_data) * N2); 89 | 90 | for (i = 0; i < N2; ++i) { 91 | temp1 = -inp[i].im - inp[N2-i].im ; 92 | temp2 = -inp[N2-i].re + inp[i].re ; 93 | cinp[i].re = inp[i].re + inp[N2-i].re + (temp1 * obj->twiddle2[i].re) - (temp2 * obj->twiddle2[i].im); 94 | cinp[i].im = inp[i].im - inp[N2-i].im + (temp2 * obj->twiddle2[i].re) + (temp1 * obj->twiddle2[i].im); 95 | } 96 | 97 | fft_exec(obj->cobj,cinp,coup); 98 | for (i = 0; i < N2; ++i) { 99 | oup[2*i] = coup[i].re; 100 | oup[2*i+1] = coup[i].im; 101 | } 102 | free(cinp); 103 | free(coup); 104 | 105 | 106 | } 107 | 108 | void free_real_fft(fft_real_object object) { 109 | free_fft(object->cobj); 110 | free(object); 111 | } 112 | 113 | -------------------------------------------------------------------------------- /src/util/exception.h: -------------------------------------------------------------------------------- 1 | #ifndef EXCEPTION_H__ 2 | #define EXCEPTION_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | 13 | #define DO_TRACE_ 14 | #define DO_NOTE_ 15 | #define DO_CLOCK_ 16 | 17 | #define EX_PRINT( MSG,args...) printf(MSG, ##args); fflush(stdout); 18 | #define EX_ERROR( MSG,args...) printf(MSG, ##args); fflush(stderr); 19 | 20 | #ifdef DO_TRACE_ 21 | #define EX_TRACE( MSG,args...) printf(MSG, ##args); fflush(stdout); 22 | #define EX_CUR_WORKSPACE() printf("%s", get_current_dir_name()); fflush(stdout); 23 | #else 24 | #define EX_TRACE( MSG,args...) 25 | #define EX_CUR_WORKSPACE() 26 | #endif 27 | 28 | #ifdef DO_NOTE_ 29 | #define EX_NOTE(X) X 30 | #else 31 | #define EX_NOTE(X) 32 | #endif 33 | 34 | #ifdef DO_CLOCK_ 35 | #define _DASH "------------------------------------------------------------------------------\n" 36 | #define _WAVE "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n" 37 | static const char* wday12310[] = {"Sun","Mon","Tue","Wed","Thu"," Fri","Sat"}; 38 | #define EX_TIME_BEGIN( MSG,args...) {time_t time_begin0112;clock_t clock_begin2290;{printf(MSG, ##args); \ 39 | time(&time_begin0112);clock_begin2290 = clock(); struct tm *p; p=localtime(&time_begin0112);\ 40 | printf("[Beginning] %d/%d/%d ", (1900+p->tm_year),(1+p->tm_mon), p->tm_mday); \ 41 | printf("%s %d:%d:%d\n", wday12310[p->tm_wday],p->tm_hour, p->tm_min, p->tm_sec);} fflush(stdout); 42 | #define EX_TIME_END( MSG,args...) time_t time_end8013;clock_t clock_end2520;{printf(MSG, ##args); \ 43 | time(&time_end8013);clock_end2520 = clock(); struct tm *p;p=localtime(&time_end8013); \ 44 | printf("[Finished] %d/%d/%d ", (1900+p->tm_year),(1+p->tm_mon), p->tm_mday); \ 45 | printf("%s %d:%d:%d (time elapse: %ldms)\n", wday12310[p->tm_wday],p->tm_hour, p->tm_min, \ 46 | p->tm_sec, (clock_end2520-clock_begin2290)*1000/CLOCKS_PER_SEC);}} fflush(stdout); 47 | #define EX_BEGIN_CLOCK() clock_t clock_begin2290;{clock_begin2290 = clock();} 48 | #define EX_END_CLOCK() clock_t clock_end2520;{clock_end2520 = clock();} 49 | #define EX_ELAPSE() (clock_end2520-clock_begin2290)*1000/CLOCKS_PER_SEC 50 | #else 51 | #define EX_TIME_BEGIN( MSG,args...) 52 | #define EX_TIME_END( MSG,args...) 53 | #define EX_BEGIN_CLOCK() 54 | #define EX_END_CLOCK() 55 | #define EX_ELAPSE() 0 56 | #endif 57 | 58 | namespace ex{ 59 | 60 | class Exception 61 | { 62 | private: 63 | std::string msg; 64 | public: 65 | Exception(std::string _msg):msg(_msg){} 66 | const char* Msg(){ return msg.c_str();} 67 | }; 68 | 69 | void EX_THROW(const char* x); 70 | 71 | //ex::Puts("", MSG, ##args, "\0"); 72 | // void Puts(const char* msg, ...) 73 | // { 74 | // va_list args; 75 | // char* str; 76 | // va_start(args, msg); 77 | // 78 | // while(1){ 79 | // str = va_arg(args, char*); 80 | // if(strcmp(str, "\0")==0){ 81 | // break; 82 | // } 83 | // std::cout< 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | namespace g{ 14 | namespace proc{ 15 | 16 | //================== Sheng added for Transfer alignment between Renmin_style and Sheng_style ==================// 17 | //-> AfpCor relevant 18 | long Ali1_To_AfpCor(long n1,long n2,vector &ali1, 19 | vector > &AFP_Cor, long thres=0); 20 | 21 | long Ali2_To_AfpCor(long n1,long n2,vector &ali2, 22 | vector > &AFP_Cor, long thres=0); 23 | 24 | void AfpCor_To_Ali1_Ali2(long n1,long n2, 25 | vector > &AFP_Cor, 26 | vector &ali1,vector &ali2); 27 | 28 | //-> AliPair relevant 29 | void Ali1_To_AliPair(long n1,long n2,vector &ali1, 30 | vector > & alignment_out); 31 | 32 | void Ali2_To_AliPair(long n1,long n2,vector &ali2, 33 | vector > & alignment_out); 34 | 35 | void AliPair_To_Ali1_Ali2(long n1,long n2, 36 | vector > & alignment_in, 37 | vector &ali1,vector &ali2); 38 | 39 | //-> given alignment return boundary 40 | void From_Align_Get_Bound(long moln1,long moln2,vector > &align, 41 | vector > &bound,long neib); 42 | 43 | void Renmin_To_Sheng_align(long moln1,long moln2, 44 | vector > &align_in, vector > &align_out); 45 | 46 | void Sheng_To_Renmin_align(long moln1,long moln2, 47 | vector > &align_in, vector > &align_out); 48 | 49 | void Sheng_To_Renmin_bound(long moln1,long moln2, 50 | vector > &bound_in, vector > &bound_out); 51 | 52 | //================================= sheng modify ======================//over 53 | 54 | //-- Z normalization --// 55 | void ZScoreNormalize(std::vector& signals, double* avg = NULL, double* stdev = NULL); 56 | 57 | //-- Peak pick --// 58 | void LaplaceDiff(const std::vector& raw, std::vector& ldiff); 59 | void Diff(const std::vector& raw, std::vector& diff); 60 | void PeakPick(const std::vector& raw, std::vector >& peaks); 61 | 62 | //-- Dynamic Time Warping --// 63 | double DynamicTimeWarping_global(const std::vector& seq1, const std::vector& seq2, std::vector >& alignment); 64 | double DynamicTimeWarping_local(const std::vector& seq1, const std::vector& seq2, std::vector >& alignment); 65 | double DynamicTimeWarping(const std::vector& seq1, const std::vector& seq2, std::vector >& alignment); 66 | 67 | //-- constrained (bound) DTW --// 68 | double BoundDynamicTimeWarping(const std::vector& seq1, const std::vector& seq2, const std::vector >& bound, std::vector >& alignment); 69 | /** Left path is blocked*/ 70 | double BoundDynamicTimeWarpingR(const std::vector& seq1, const std::vector& seq2, const std::vector >& bound, std::vector >& alignment); 71 | 72 | } 73 | 74 | } 75 | 76 | 77 | #endif 78 | 79 | -------------------------------------------------------------------------------- /src/sig2peak/main.cpp: -------------------------------------------------------------------------------- 1 | #include "opts.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "proc/cwdtw.h" 9 | #include "util/exception.h" 10 | #include "wavelib.h" 11 | #include 12 | #include 13 | #include 14 | 15 | using namespace std; 16 | using namespace g::proc; 17 | 18 | //-------- utility ------// 19 | void getBaseName(string &in,string &out,char slash,char dot) 20 | { 21 | int i,j; 22 | int len=(int)in.length(); 23 | for(i=len-1;i>=0;i--) 24 | { 25 | if(in[i]==slash)break; 26 | } 27 | i++; 28 | for(j=len-1;j>=0;j--) 29 | { 30 | if(in[j]==dot)break; 31 | } 32 | if(j==-1)j=len; 33 | out=in.substr(i,j-i); 34 | } 35 | void getRootName(string &in,string &out,char slash) 36 | { 37 | int i; 38 | int len=(int)in.length(); 39 | for(i=len-1;i>=0;i--) 40 | { 41 | if(in[i]==slash)break; 42 | } 43 | if(i<=0)out="."; 44 | else out=in.substr(0,i); 45 | } 46 | //---------------------- utility ------//over 47 | 48 | 49 | 50 | //----------------- main -------------------// 51 | int main(int argc, char **argv) 52 | { 53 | struct options opts; 54 | opts.scale0 = sqrt(2); 55 | opts.ZorNOT = 0; //0 for NOT perform Z-normalize 56 | opts.posout = 0; //0 for NOT output the position of each peak 57 | 58 | //----- parse arguments -----// 59 | if(GetOpts(argc, argv, &opts) < 0){ 60 | EX_TRACE("**WRONG INPUT!**\n"); 61 | return -1; 62 | } 63 | 64 | std::string input=""; 65 | std::string output=""; 66 | input=opts.input; 67 | output=opts.output; 68 | if(input=="" || output=="") 69 | { 70 | fprintf(stderr,"input or output is NULL \n"); 71 | return -1; 72 | } 73 | 74 | //======================= START Procedure ===================================// 75 | 76 | //=========================================// 77 | //----- 1. read genome translated signal -----// 78 | std::vector reference; 79 | if(!g::io::ReadSignalSequence(opts.input,reference)){ 80 | EX_TRACE("Cannot open %s.\n", opts.input); 81 | return -1; 82 | } 83 | std::string genom_name_orig=opts.input; 84 | std::string genom_name; 85 | getBaseName(genom_name_orig,genom_name,'/','.'); 86 | 87 | 88 | //printf("read done \n"); 89 | 90 | //==================================================// 91 | //----- 2. process initial input signals ----------// 92 | if(opts.ZorNOT==1){ 93 | g::proc::ZScoreNormalize(reference); 94 | } 95 | 96 | //====================================================// 97 | //----- 3. continous wavelet transform --------------// 98 | std::vector > rcwt; 99 | long npyr = 1; // default: 1 100 | double scale0 = opts.scale0; // default: sqrt(2) 101 | double dscale = 1; // default: 1 102 | g::cwdtw::CWTAnalysis(reference, rcwt, scale0, dscale, npyr); 103 | 104 | //printf("proc CWT done \n"); 105 | 106 | //----- 4. Zscore normaliza on both CWT signals -----// 107 | //if multiscale is used, pyr logical should be added. 108 | if(opts.ZorNOT==1){ 109 | g::proc::ZScoreNormalize(rcwt[0]); 110 | } 111 | std::vector > sigpeaks; 112 | g::proc::PeakPick(rcwt[0], sigpeaks); 113 | 114 | //printf("proc PeakPick done \n"); 115 | 116 | //=================================================// 117 | //----- 5. output final alignment to file -------// 118 | FILE *fp=fopen(output.c_str(),"wb"); 119 | for(long i=0;i& genomes) 4 | { 5 | std::ifstream in(name); 6 | if(!in.good()) { 7 | return false; 8 | } 9 | 10 | //-> skip first header 11 | std::string buf; 12 | if(!getline(in, buf)){ 13 | return false; 14 | } 15 | 16 | while(in.good()){ 17 | char item; 18 | in>>item; 19 | if(in.fail()){ 20 | break; 21 | } 22 | genomes.push_back(item); 23 | } 24 | in.close(); 25 | 26 | return true; 27 | } 28 | 29 | bool g::io::WriteATCG(const char* name, const std::vector& genomes) 30 | { 31 | std::ostringstream o; 32 | for(size_t i = 0; i < genomes.size(); i++){ 33 | o<& signals) 46 | { 47 | std::ifstream in(name); 48 | if(!in.good()) { 49 | return false; 50 | } 51 | 52 | while(in.good()){ 53 | double item; 54 | in>>item; 55 | if(in.fail()){ 56 | break; 57 | } 58 | signals.push_back(item); 59 | } 60 | in.close(); 61 | 62 | return true; 63 | } 64 | 65 | bool g::io::ReadSignalSequence_int(const char* name, std::vector& signals) 66 | { 67 | std::ifstream in(name); 68 | if(!in.good()) { 69 | return false; 70 | } 71 | 72 | while(in.good()){ 73 | int item; 74 | in>>item; 75 | if(in.fail()){ 76 | break; 77 | } 78 | signals.push_back(item); 79 | } 80 | in.close(); 81 | 82 | return true; 83 | } 84 | 85 | bool g::io::WriteSignalSequence(const char* name, const std::vector& signals) 86 | { 87 | std::ostringstream o; 88 | for(size_t i = 0; i < signals.size(); i++){ 89 | o<& signals) 102 | { 103 | std::ostringstream o; 104 | for(size_t i = 0; i < signals.size(); i++){ 105 | o<& signals, 120 | const std::vector& kmer_rec) 121 | { 122 | std::ostringstream o; 123 | for(size_t i = 0; i < signals.size(); i++){ 124 | o<& signals, 138 | const std::vector& kmer_rec) 139 | { 140 | std::ostringstream o; 141 | for(size_t i = 0; i < signals.size(); i++){ 142 | o< 5 | #include 6 | #include 7 | extern "C" { 8 | #include 9 | } 10 | #include "util/exception.h" 11 | 12 | struct options { 13 | char input[65532]; 14 | char output[65532]; 15 | double scale0; 16 | int ZorNOT; 17 | int posout; 18 | }; 19 | 20 | inline int GetOpts(int argc, char **argv, options* opts_){ 21 | 22 | static struct option longopts[] = { 23 | { "help", no_argument, NULL, 'h' }, 24 | { "input", required_argument, NULL, 'i' }, 25 | { "output", required_argument, NULL, 'o' }, 26 | { "scale", required_argument, NULL, 's' }, 27 | { "ZorNOT", no_argument, NULL, 'z' }, 28 | { "posout", no_argument, NULL, 'p' }, 29 | { NULL, 0, NULL, 0 } 30 | }; 31 | 32 | if((argc != 7 && argc != 9 && argc != 11 ) && argc >= 3 || (argc == 2 && argv[1][0] != '-' && argv[1][1] != 'h') || argc == 1){ 33 | EX_TRACE("[-i SIGNAL INPUT][-o CWT OUTPUT][-s SCALE]([-z ZNORM_or_NOT=0])([-p OUT_POSITION])\n"); 34 | EX_TRACE("[note]: if -z is set to 0, then NO Znormalize will be performd \n"); 35 | EX_TRACE(" if -p is set to 1, then the position of each peak will be output \n"); 36 | return -1; 37 | } 38 | 39 | int ch; 40 | while((ch = getopt_long(argc, argv, "hi:o:s:z:p:", longopts, NULL))!= -1){ 41 | switch (ch) { 42 | 43 | case '?': 44 | { 45 | EX_TRACE("Invalid option '%s'.", argv[optind-1]); 46 | return -1; 47 | } 48 | 49 | case ':': 50 | { 51 | EX_TRACE("Missing option argument for '%s'.", argv[optind-1]); 52 | return -1; 53 | } 54 | 55 | case 'h': 56 | { 57 | EX_TRACE("[-i GENOME INPUT][-o SIGNAL OUTPUT]([-z ZNORM_or_NOT=0])([-p OUT_POSITION])\n"); 58 | EX_TRACE("[note]: if -z is set to 0, then NO Znormalize will be performd \n"); 59 | EX_TRACE(" if -p is set to 1, then the position of each peak will be output \n"); 60 | return -1; 61 | } 62 | 63 | case 'i': 64 | { 65 | std::istringstream iss(optarg); 66 | iss >> opts_->input; 67 | if (iss.fail()){ 68 | EX_TRACE("Invalid argument '%s'.", optarg); 69 | return -1; 70 | } 71 | } 72 | break; 73 | 74 | case 'o': 75 | { 76 | std::istringstream iss(optarg); 77 | iss >> opts_->output; 78 | if (iss.fail()){ 79 | EX_TRACE("Invalid argument '%s'.", optarg); 80 | return -1; 81 | } 82 | } 83 | break; 84 | 85 | case 's': 86 | { 87 | std::istringstream iss(optarg); 88 | iss >> opts_->scale0; 89 | if (iss.fail()){ 90 | EX_TRACE("Invalid argument '%s'.", optarg); 91 | return -1; 92 | } 93 | } 94 | break; 95 | 96 | case 'z': 97 | { 98 | std::istringstream iss(optarg); 99 | iss >> opts_->ZorNOT; 100 | if (iss.fail()){ 101 | EX_TRACE("Invalid argument '%s'.", optarg); 102 | return -1; 103 | } 104 | } 105 | break; 106 | 107 | case 'p': 108 | { 109 | std::istringstream iss(optarg); 110 | iss >> opts_->posout; 111 | if (iss.fail()){ 112 | EX_TRACE("Invalid argument '%s'.", optarg); 113 | return -1; 114 | } 115 | } 116 | break; 117 | 118 | 119 | case 0: 120 | break; 121 | 122 | default: 123 | assert(false); 124 | } 125 | } 126 | return 1; 127 | } 128 | 129 | #endif 130 | -------------------------------------------------------------------------------- /lib/wavelib/src/conv.c: -------------------------------------------------------------------------------- 1 | /* 2 | * conv.c 3 | * 4 | * Created on: May 1, 2013 5 | * Author: Rafat Hussain 6 | */ 7 | 8 | #include "conv.h" 9 | 10 | int factorf(int M) { 11 | int N; 12 | N = M; 13 | while (N%7 == 0){ 14 | N = N/7; 15 | } 16 | while (N%3 == 0){ 17 | N = N/3; 18 | } 19 | while (N%5 == 0){ 20 | N = N/5; 21 | } 22 | while (N%2 == 0){ 23 | N = N/2; 24 | } 25 | 26 | return N; 27 | } 28 | 29 | 30 | int findnext(int M) { 31 | int N; 32 | N = M; 33 | 34 | while (factorf(N) != 1) { 35 | ++N; 36 | } 37 | 38 | return N; 39 | 40 | } 41 | 42 | int findnexte(int M) { 43 | int N; 44 | N = M; 45 | 46 | while (factorf(N) != 1 || N%2 != 0) { 47 | ++N; 48 | } 49 | 50 | return N; 51 | 52 | } 53 | 54 | 55 | conv_object conv_init(int N, int L) { 56 | 57 | conv_object obj = NULL; 58 | int conv_len; 59 | conv_len = N + L - 1; 60 | 61 | obj = (conv_object) malloc (sizeof(struct conv_set)); 62 | 63 | //obj->clen = npow2(conv_len); 64 | //obj->clen = conv_len; 65 | obj->clen = findnexte(conv_len); 66 | obj->ilen1 = N; 67 | obj->ilen2 = L; 68 | 69 | obj->fobj = fft_real_init(obj->clen,1); 70 | obj->iobj = fft_real_init(obj->clen,-1); 71 | 72 | return obj; 73 | 74 | } 75 | 76 | void conv_directx(fft_type *inp1,int N, fft_type *inp2, int L,fft_type *oup){ 77 | int M,k,n; 78 | 79 | M = N + L - 1; 80 | 81 | for (k = 0; k < M;++k) { 82 | oup[k] = 0.0; 83 | for ( n = 0; n < N; ++n) { 84 | if ( (k-n) >= 0 && (k-n) < L ) { 85 | oup[k]+= inp1[n] * inp2[k-n]; 86 | } 87 | } 88 | 89 | } 90 | 91 | } 92 | 93 | void conv_direct(fft_type *inp1,int N, fft_type *inp2, int L,fft_type *oup) { 94 | 95 | int M,k,m,i; 96 | fft_type t1,tmin; 97 | 98 | M = N + L -1; 99 | i = 0; 100 | 101 | if (N >= L) { 102 | 103 | for (k = 0; k < L; k++) { 104 | oup[k] = 0.0; 105 | for (m = 0; m <= k;m++) { 106 | oup[k]+= inp1[m] * inp2[k-m]; 107 | } 108 | } 109 | 110 | for (k = L; k < M; k++) { 111 | oup[k] = 0.0; 112 | i++; 113 | t1 = L + i; 114 | tmin = MIN(t1,N); 115 | for (m = i; m < tmin;m++) { 116 | oup[k]+= inp1[m] * inp2[k-m]; 117 | } 118 | } 119 | 120 | 121 | } else { 122 | for (k = 0; k < N; k++) { 123 | oup[k] = 0.0; 124 | for (m = 0; m <= k;m++) { 125 | oup[k]+= inp2[m] * inp1[k-m]; 126 | } 127 | } 128 | 129 | for (k = N; k < M; k++) { 130 | oup[k] = 0.0; 131 | i++; 132 | t1 = N + i; 133 | tmin = MIN(t1,L); 134 | for (m = i; m < tmin;m++) { 135 | oup[k]+= inp2[m] * inp1[k-m]; 136 | } 137 | } 138 | 139 | } 140 | 141 | 142 | } 143 | 144 | 145 | void conv_fft(const conv_object obj,fft_type *inp1,fft_type *inp2,fft_type *oup) { 146 | int i,N,L1,L2,ls; 147 | fft_type* a; 148 | fft_type* b; 149 | fft_data* c; 150 | fft_data* ao; 151 | fft_data* bo; 152 | fft_type* co; 153 | 154 | N = obj->clen; 155 | L1 = obj->ilen1; 156 | L2 = obj->ilen2; 157 | ls = L1 + L2 - 1; 158 | 159 | a = (fft_type*) malloc (sizeof(fft_data) * N); 160 | b = (fft_type*) malloc (sizeof(fft_data) * N); 161 | c = (fft_data*) malloc (sizeof(fft_data) * N); 162 | ao = (fft_data*) malloc (sizeof(fft_data) * N); 163 | bo = (fft_data*) malloc (sizeof(fft_data) * N); 164 | co = (fft_type*) malloc (sizeof(fft_data) * N); 165 | 166 | for (i = 0; i < N;i++) { 167 | if (i < L1) { 168 | a[i] = inp1[i]; 169 | } else { 170 | a[i] = 0.0; 171 | } 172 | 173 | if (i < L2) { 174 | b[i] = inp2[i]; 175 | } else { 176 | b[i] = 0.0; 177 | } 178 | 179 | } 180 | 181 | fft_r2c_exec(obj->fobj,a,ao); 182 | fft_r2c_exec(obj->fobj,b,bo); 183 | 184 | for (i = 0; i < N;i++) { 185 | c[i].re = ao[i].re * bo[i].re - ao[i].im * bo[i].im; 186 | c[i].im = ao[i].im * bo[i].re + ao[i].re * bo[i].im; 187 | } 188 | 189 | fft_c2r_exec(obj->iobj,c,co); 190 | 191 | for (i = 0; i < ls;i++) { 192 | oup[i] = co[i]/N; 193 | } 194 | 195 | free(a); 196 | free(b); 197 | free(c); 198 | free(ao); 199 | free(bo); 200 | free(co); 201 | 202 | 203 | } 204 | 205 | 206 | void free_conv(conv_object object) { 207 | free_real_fft(object->fobj); 208 | free_real_fft(object->iobj); 209 | free(object); 210 | } 211 | -------------------------------------------------------------------------------- /src/seq2sig/opts.h: -------------------------------------------------------------------------------- 1 | #ifndef OPTS_H__ 2 | #define OPTS_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | extern "C" { 8 | #include 9 | } 10 | #include "util/exception.h" 11 | 12 | struct options { 13 | char input[65532]; 14 | char output[65532]; 15 | int scale=1; 16 | int kmer=1; 17 | int zsco=0; 18 | int rna=0; 19 | int name=0; 20 | }; 21 | 22 | inline int GetOpts(int argc, char **argv, options* opts_){ 23 | 24 | static struct option longopts[] = { 25 | { "help", no_argument, NULL, 'h' }, 26 | { "output", required_argument, NULL, 'o' }, 27 | { "input", required_argument, NULL, 'i' }, 28 | { "scale", required_argument, NULL, 's' }, 29 | { "kmer", required_argument, NULL, 'k' }, 30 | { "zsco", required_argument, NULL, 'z' }, 31 | { "rna", required_argument, NULL, 'R' }, 32 | { "name", required_argument, NULL, 'N' }, 33 | { NULL, 0, NULL, 0 } 34 | }; 35 | 36 | if((argc != 5 && argc != 7 && argc != 9 && argc != 11 && argc != 13 && argc != 15 ) && argc >= 3 || (argc == 2 && argv[1][0] != '-' && argv[1][1] != 'h') || argc == 1){ 37 | EX_TRACE("[-i GENOME INPUT][-o SIGNAL OUTPUT]([-s SCALE=1])([-k kmer=1])([-z zsco=0])([-R RNA=0])([-N name=0])\n"); 38 | return -1; 39 | } 40 | 41 | int ch; 42 | while((ch = getopt_long(argc, argv, "hi:o:s:k:z:R:N:", longopts, NULL))!= -1){ 43 | switch (ch) { 44 | 45 | case '?': 46 | { 47 | EX_TRACE("Invalid option '%s'.", argv[optind-1]); 48 | return -1; 49 | } 50 | 51 | case ':': 52 | { 53 | EX_TRACE("Missing option argument for '%s'.", argv[optind-1]); 54 | return -1; 55 | } 56 | 57 | case 'h': 58 | { 59 | EX_TRACE("[-i GENOME INPUT][-o SIGNAL OUTPUT]([-s SCALE=1])([-k KMER=1])([-z zsco=0])([-R RNA=0])([-N name=0])\n"); 60 | EX_TRACE("[note]: to use 5mer pore model, set -k 0; to use 6mer pore model, set -k 1\n"); 61 | EX_TRACE(" if zsco is set to 0, then Z-normalize pore model. \n"); 62 | EX_TRACE(" if RNA is set to 0, use DNA pore mode; 1 for 200mv RNA, -1 for 180mv RNA \n"); 63 | EX_TRACE(" if name is set to 1, then output Kmer name in the output file. \n"); 64 | return -1; 65 | } 66 | 67 | case 'i': 68 | { 69 | std::istringstream iss(optarg); 70 | iss >> opts_->input; 71 | if (iss.fail()){ 72 | EX_TRACE("Invalid argument '%s'.", optarg); 73 | return -1; 74 | } 75 | } 76 | break; 77 | 78 | case 'o': 79 | { 80 | std::istringstream iss(optarg); 81 | iss >> opts_->output; 82 | if (iss.fail()){ 83 | EX_TRACE("Invalid argument '%s'.", optarg); 84 | return -1; 85 | } 86 | } 87 | break; 88 | 89 | case 's': 90 | { 91 | std::istringstream iss(optarg); 92 | iss >> opts_->scale; 93 | if (iss.fail()){ 94 | EX_TRACE("Invalid argument '%s'.", optarg); 95 | return -1; 96 | } 97 | } 98 | break; 99 | 100 | case 'k': 101 | { 102 | std::istringstream iss(optarg); 103 | iss >> opts_->kmer; 104 | if (iss.fail()){ 105 | EX_TRACE("Invalid argument '%s'.", optarg); 106 | return -1; 107 | } 108 | } 109 | break; 110 | 111 | case 'z': 112 | { 113 | std::istringstream iss(optarg); 114 | iss >> opts_->zsco; 115 | if (iss.fail()){ 116 | EX_TRACE("Invalid argument '%s'.", optarg); 117 | return -1; 118 | } 119 | } 120 | break; 121 | 122 | case 'R': 123 | { 124 | std::istringstream iss(optarg); 125 | iss >> opts_->rna; 126 | if (iss.fail()){ 127 | EX_TRACE("Invalid argument '%s'.", optarg); 128 | return -1; 129 | } 130 | } 131 | break; 132 | 133 | case 'N': 134 | { 135 | std::istringstream iss(optarg); 136 | iss >> opts_->name; 137 | if (iss.fail()){ 138 | EX_TRACE("Invalid argument '%s'.", optarg); 139 | return -1; 140 | } 141 | } 142 | break; 143 | 144 | case 0: 145 | break; 146 | 147 | default: 148 | assert(false); 149 | } 150 | } 151 | return 1; 152 | } 153 | 154 | #endif 155 | -------------------------------------------------------------------------------- /README: -------------------------------------------------------------------------------- 1 | #========== 2 | # Abstract: 3 | #========== 4 | 5 | Title: 6 | cwDTW: Continuous Wavelet Dynamic Time Warping for unbalanced global mapping of two signals 7 | 8 | Author: 9 | Renmin Han, 10 | Yu Li, 11 | Xin Gao, 12 | Sheng Wang 13 | 14 | Contact email: 15 | xin.gao@kaust.edu.sa 16 | realbigws@gmail.com 17 | 18 | Reference: 19 | https://academic.oup.com/bioinformatics/article-abstract/34/17/i722/5093233 20 | 21 | 22 | 23 | #========= 24 | # Install: 25 | #========= 26 | 27 | ./install.sh 28 | 29 | 30 | #======= 31 | # Usage: 32 | #======= 33 | 34 | #---- type ----# 35 | ./cwDTW -h 36 | 37 | 38 | #---- usage ---# 39 | ----------- cwDTW ---------- 40 | version v0.03 (OCT 22 2017) 41 | ------------------------------------------------------------- 42 | required: 43 | [-i SHORT SIGNAL][-p LONG SIGNAL][-o OUTPUT] 44 | optional: 45 | ([-r RADIUS])([-l LEVEL])([-s SCALE]) 46 | ------------------------------------------------------------- 47 | **** required: ****** 48 | SHORT SIGNALE: (reference) sequence signal from ATCG...; 49 | LONG SIGNAL: (nanopore) raw electrical current signal; 50 | OUTPUT: signal mapping result; if not specified, then no output be generated; 51 | **** key parameters: ****** 52 | RADIUS: warp search radius (default 50); 53 | LEVEL: sampling level in continous wavelet (default 3); 54 | SCALE: base scale in continous wavelet (default sqrt(2)); 55 | 56 | 57 | 58 | 59 | #=============== 60 | # Screen output: 61 | #=============== 62 | 63 | 1 2 3 4 5 64 | ------------------------------------------------------------------------------------------------------- 65 | 002a08b9-0248-4929-9759-2d5c0942076d 002a08b9-0248-4929-9759-2d5c0942076d 22089.546144 127006 0.173925 66 | 67 | --------- 68 | [Legend]: 69 | --------- 70 | 71 | the 1st column shows the name of the first input signal, 72 | the 2nd column shows the name of the second input signal, 73 | 74 | the 3rd column shows the overall distance after Dynamic Time Warping (DTW), 75 | the 4th colmnn shows the length of the warping path (or, length of alignment), 76 | 77 | the 5th column shows the normalized distance of a warping path. 78 | 79 | 80 | 81 | 82 | #=============== 83 | # Output format: 84 | #=============== 85 | 86 | 1 2 3 4 5 6 7 87 | ------------------------------------------------------------------------------------------------------------------------ 88 | 1 1 | 316 550 | -1.16628 1.04565 diff: 2.21193 89 | 2 2 | 347 433 | -0.526507 -0.560209 diff: 0.033702 90 | 3 3 | 319 411 | -1.10436 -0.862165 diff: 0.242199 91 | 3 4 | 319 409 | -1.10436 -0.889616 diff: 0.214749 92 | 3 5 | 319 408 | -1.10436 -0.903341 diff: 0.201023 93 | 3 6 | 319 389 | -1.10436 -1.16412 diff: 0.0597573 94 | 3 7 | 319 389 | -1.10436 -1.16412 diff: 0.0597573 95 | 3 8 | 319 377 | -1.10436 -1.32883 diff: 0.224461 96 | 3 9 | 319 391 | -1.10436 -1.13667 diff: 0.0323067 97 | 98 | --------- 99 | [Legend]: 100 | --------- 101 | 102 | the 1st column shows the mapping of the first position (e.g., on expected signal) starting from 1, 103 | the 2nd column shows the mapping of the second position (e.g., on raw signal) starting from 1, 104 | 105 | the 3rd column displays the original value of the first input signal (e.g., on expected signal), 106 | the 4th column displays the original value of the second input signal (e.g., on raw signal), 107 | 108 | the 5th column indicates the Z-normalized value of the first input signal (e.g., on expected signal), 109 | the 6th column indicates the Z-normalized value of the second input signal (e.g., on raw signal), 110 | 111 | the 7th column illustrates the absolute difference between the two Z-normalized values. 112 | 113 | 114 | 115 | #========= 116 | # Example: 117 | #========= 118 | 119 | #-> 1. generate genome signal from DNA sequence via pore model. 120 | ./seq2sig -i example/002a08b9-0248-4929-9759-2d5c0942076d.fasta -o 002a08b9-0248-4929-9759-2d5c0942076d.seqsig -s 1 -z 0 121 | 122 | #-> 2. generate coarsening signal via peak-pick on CWT spectrum. 123 | ./sig2peak -i example/002a08b9-0248-4929-9759-2d5c0942076d.seqsig -o 002a08b9-0248-4929-9759-2d5c0942076d.peak_seqsig -s 2.828 -z 1 124 | ./sig2peak -i example/002a08b9-0248-4929-9759-2d5c0942076d.rawsig -o 002a08b9-0248-4929-9759-2d5c0942076d.peak_rawsig -s 22.715 -z 1 #-> 22.715=2.828*126965/15807:wq 125 | 126 | #-> 3. perform mapping between nanopore signal and genome signal. 127 | ./cwDTW -i example/002a08b9-0248-4929-9759-2d5c0942076d.seqsig -p example/002a08b9-0248-4929-9759-2d5c0942076d.rawsig -o align_out 128 | 129 | 130 | -------------------------------------------------------------------------------- /lib/wavelib/src/wavefunc.c: -------------------------------------------------------------------------------- 1 | #include "wavefunc.h" 2 | 3 | void meyer(int N,double lb,double ub,double *phi,double *psi,double *tgrid) { 4 | int M,i; 5 | double *w; 6 | double delta,j; 7 | double theta,x,x2,x3,x4,v,cs,sn; 8 | double wf; 9 | fft_data *phiw,*psiw,*oup; 10 | fft_object obj; 11 | 12 | M = divideby(N, 2); 13 | 14 | if (M == 0) { 15 | printf("Size of Wavelet must be a power of 2"); 16 | exit(1); 17 | } 18 | if (lb >= ub) { 19 | printf("upper bound must be greater than lower bound"); 20 | exit(1); 21 | } 22 | 23 | obj = fft_init(N,-1); 24 | w = (double*)malloc(sizeof(double)*N); 25 | phiw = (fft_data*) malloc (sizeof(fft_data) * N); 26 | psiw = (fft_data*) malloc (sizeof(fft_data) * N); 27 | oup = (fft_data*) malloc (sizeof(fft_data) * N); 28 | 29 | delta = 2 * (ub-lb) / PI2; 30 | 31 | j = (double) N; 32 | j *= -1.0; 33 | 34 | for(i = 0; i < N;++i) { 35 | w[i] = j / delta; 36 | j += 2.0; 37 | psiw[i].re = psiw[i].im = 0.0; 38 | phiw[i].re = phiw[i].im = 0.0; 39 | } 40 | 41 | 42 | for(i = 0; i < N;++i) { 43 | wf = fabs(w[i]); 44 | if (wf <= PI2/3.0) { 45 | phiw[i].re = 1.0; 46 | } 47 | if (wf > PI2/3.0 && wf <= 2 * PI2 / 3.0) { 48 | x = (3 * wf / PI2) - 1.0; 49 | x2 = x*x; 50 | x3 = x2 * x; 51 | x4 = x3 *x; 52 | v = x4 *(35 - 84*x + 70*x2 - 20*x3); 53 | theta = v * PI2 / 4.0; 54 | cs = cos(theta); 55 | sn = sin(theta); 56 | 57 | phiw[i].re = cs; 58 | psiw[i].re = cos(w[i]/2.0) * sn; 59 | psiw[i].im = sin(w[i]/2.0) * sn; 60 | } 61 | if (wf > 2.0 * PI2/3.0 && wf <= 4 * PI2 / 3.0) { 62 | x = (1.5 * wf / PI2) - 1.0; 63 | x2 = x*x; 64 | x3 = x2 * x; 65 | x4 = x3 *x; 66 | v = x4 *(35 - 84*x + 70*x2 - 20*x3); 67 | theta = v * PI2 / 4.0; 68 | cs = cos(theta); 69 | 70 | psiw[i].re = cos(w[i]/2.0) * cs; 71 | psiw[i].im = sin(w[i]/2.0) * cs; 72 | } 73 | } 74 | 75 | 76 | nsfft_exec(obj,phiw,oup,lb,ub,tgrid); 77 | 78 | 79 | for(i = 0; i < N;++i) { 80 | phi[i] = oup[i].re/N; 81 | } 82 | 83 | nsfft_exec(obj,psiw,oup,lb,ub,tgrid); 84 | 85 | 86 | for(i = 0; i < N;++i) { 87 | psi[i] = oup[i].re/N; 88 | } 89 | 90 | 91 | 92 | free(oup); 93 | free(phiw); 94 | free(psiw); 95 | free(w); 96 | } 97 | 98 | void gauss(int N,int p,double lb,double ub,double *psi,double *t) { 99 | double delta,num,den,t2,t4; 100 | int i; 101 | 102 | if (lb >= ub) { 103 | printf("upper bound must be greater than lower bound"); 104 | exit(1); 105 | } 106 | 107 | t[0] = lb; 108 | t[N-1] = ub; 109 | delta = (ub - lb) / (N-1); 110 | for(i = 1; i < N-1;++i) { 111 | t[i] = lb + delta * i; 112 | } 113 | 114 | den = sqrt(gamma(p+0.5)); 115 | 116 | if ((p+1)%2 == 0) { 117 | num = 1.0; 118 | } else { 119 | num = -1.0; 120 | } 121 | 122 | num /= den; 123 | 124 | //printf("\n%g\n",num); 125 | 126 | if (p == 1) { 127 | for(i = 0; i < N;++i) { 128 | psi[i] = -t[i] * exp(- t[i] * t[i]/2.0) * num; 129 | } 130 | } else if (p == 2) { 131 | for(i = 0; i < N;++i) { 132 | t2 = t[i] * t[i]; 133 | psi[i] = (-1.0 + t2) * exp(- t2/2.0) * num; 134 | } 135 | } else if (p == 3) { 136 | for(i = 0; i < N;++i) { 137 | t2 = t[i] * t[i]; 138 | psi[i] = t[i] * (3.0 - t2) * exp(- t2/2.0) * num; 139 | } 140 | } else if (p == 4) { 141 | for(i = 0; i < N;++i) { 142 | t2 = t[i] * t[i]; 143 | psi[i] = (t2 * t2 - 6.0 * t2 + 3.0) * exp(- t2/2.0) * num; 144 | } 145 | } else if (p == 5) { 146 | for(i = 0; i < N;++i) { 147 | t2 = t[i] * t[i]; 148 | psi[i] = t[i] * (-t2 * t2 + 10.0 * t2 - 15.0) * exp(- t2/2.0) * num; 149 | } 150 | } else if (p == 6) { 151 | for(i = 0; i < N;++i) { 152 | t2 = t[i] * t[i]; 153 | psi[i] = (t2 * t2 * t2 - 15.0 * t2 * t2 + 45.0 * t2 - 15.0) * exp(- t2/2.0) * num; 154 | } 155 | } else if (p == 7) { 156 | for(i = 0; i < N;++i) { 157 | t2 = t[i] * t[i]; 158 | psi[i] = t[i] * (-t2 * t2 * t2 + 21.0 * t2 * t2 - 105.0 * t2 + 105.0) * exp(- t2/2.0) * num; 159 | } 160 | } else if (p == 8) { 161 | for(i = 0; i < N;++i) { 162 | t2 = t[i] * t[i]; 163 | t4 = t2 * t2; 164 | psi[i] = (t4 * t4 - 28.0 * t4 * t2 + 210.0 * t4 - 420.0 * t2 + 105.0) * exp(- t2/2.0) * num; 165 | } 166 | } else if (p == 9) { 167 | for(i = 0; i < N;++i) { 168 | t2 = t[i] * t[i]; 169 | t4 = t2 * t2; 170 | psi[i] = t[i] * (- t4 * t4 + 36.0 * t4 * t2 - 378.0 * t4 + 1260.0 * t2 - 945.0) * exp(- t2/2.0) * num; 171 | } 172 | } else if (p == 10) { 173 | for(i = 0; i < N;++i) { 174 | t2 = t[i] * t[i]; 175 | t4 = t2 * t2; 176 | psi[i] = (t4 * t4 * t2 - 45.0 * t4 * t4 + 630.0 * t4 * t2 - 3150.0 * t4 + 4725.0 * t2 - 945.0) * exp(- t2/2.0) * num; 177 | } 178 | } else { 179 | printf("\n The Gaussian Derivative Wavelet is only available for Derivatives 1 to 10"); 180 | exit(1); 181 | } 182 | 183 | 184 | 185 | } 186 | 187 | void mexhat(int N,double lb,double ub,double *psi,double *t) { 188 | gauss(N,2,lb,ub,psi,t); 189 | } 190 | 191 | void morlet(int N,double lb,double ub,double *psi,double *t) { 192 | int i; 193 | double delta; 194 | 195 | if (lb >= ub) { 196 | printf("upper bound must be greater than lower bound"); 197 | exit(1); 198 | } 199 | 200 | t[0] = lb; 201 | t[N-1] = ub; 202 | delta = (ub - lb) / (N-1); 203 | for(i = 1; i < N-1;++i) { 204 | t[i] = lb + delta * i; 205 | } 206 | 207 | for(i = 0; i < N;++i) { 208 | psi[i] = exp(- t[i] * t[i] / 2.0) * cos(5 * t[i]); 209 | } 210 | } 211 | -------------------------------------------------------------------------------- /lib/wavelib/test/sst_nino3.dat: -------------------------------------------------------------------------------- 1 | -0.15 2 | -0.30 3 | -0.14 4 | -0.41 5 | -0.46 6 | -0.66 7 | -0.50 8 | -0.80 9 | -0.95 10 | -0.72 11 | -0.31 12 | -0.71 13 | -1.04 14 | -0.77 15 | -0.86 16 | -0.84 17 | -0.41 18 | -0.49 19 | -0.48 20 | -0.72 21 | -1.21 22 | -0.80 23 | 0.16 24 | 0.46 25 | 0.40 26 | 1.00 27 | 2.17 28 | 2.50 29 | 2.34 30 | 0.80 31 | 0.14 32 | -0.06 33 | -0.34 34 | -0.71 35 | -0.34 36 | -0.73 37 | -0.48 38 | -0.11 39 | 0.22 40 | 0.51 41 | 0.51 42 | 0.25 43 | -0.10 44 | -0.33 45 | -0.42 46 | -0.23 47 | -0.53 48 | -0.44 49 | -0.30 50 | 0.15 51 | 0.09 52 | 0.19 53 | -0.06 54 | 0.25 55 | 0.30 56 | 0.81 57 | 0.26 58 | 0.10 59 | 0.34 60 | 1.01 61 | -0.31 62 | -0.90 63 | -0.73 64 | -0.92 65 | -0.73 66 | -0.31 67 | -0.03 68 | 0.12 69 | 0.37 70 | 0.82 71 | 1.22 72 | 1.83 73 | 1.60 74 | 0.34 75 | -0.72 76 | -0.87 77 | -0.85 78 | -0.40 79 | -0.39 80 | -0.65 81 | 0.07 82 | 0.67 83 | 0.39 84 | 0.03 85 | -0.17 86 | -0.76 87 | -0.87 88 | -1.36 89 | -1.10 90 | -0.99 91 | -0.78 92 | -0.93 93 | -0.87 94 | -0.44 95 | -0.34 96 | -0.50 97 | -0.39 98 | -0.04 99 | 0.42 100 | 0.62 101 | 0.17 102 | 0.23 103 | 1.03 104 | 1.54 105 | 1.09 106 | 0.01 107 | 0.12 108 | -0.27 109 | -0.47 110 | -0.41 111 | -0.37 112 | -0.36 113 | -0.39 114 | 0.43 115 | 1.05 116 | 1.58 117 | 1.25 118 | 0.86 119 | 0.60 120 | 0.21 121 | 0.19 122 | -0.23 123 | -0.29 124 | 0.18 125 | 0.12 126 | 0.71 127 | 1.42 128 | 1.59 129 | 0.93 130 | -0.25 131 | -0.66 132 | -0.95 133 | -0.47 134 | 0.06 135 | 0.70 136 | 0.81 137 | 0.78 138 | 1.43 139 | 1.22 140 | 1.05 141 | 0.44 142 | -0.35 143 | -0.67 144 | -0.84 145 | -0.66 146 | -0.45 147 | -0.12 148 | -0.20 149 | -0.16 150 | -0.47 151 | -0.52 152 | -0.79 153 | -0.80 154 | -0.62 155 | -0.86 156 | -1.29 157 | -1.04 158 | -1.05 159 | -0.75 160 | -0.81 161 | -0.90 162 | -0.25 163 | 0.62 164 | 1.22 165 | 0.96 166 | 0.21 167 | -0.11 168 | -0.25 169 | -0.24 170 | -0.43 171 | 0.23 172 | 0.67 173 | 0.78 174 | 0.41 175 | 0.98 176 | 1.28 177 | 1.45 178 | 1.02 179 | 0.03 180 | -0.59 181 | -1.34 182 | -0.99 183 | -1.49 184 | -1.74 185 | -1.33 186 | -0.55 187 | -0.51 188 | -0.36 189 | -0.99 190 | 0.32 191 | 1.04 192 | 1.41 193 | 0.99 194 | 0.66 195 | 0.50 196 | 0.22 197 | 0.71 198 | -0.16 199 | 0.38 200 | 0.00 201 | -1.11 202 | -1.04 203 | 0.05 204 | -0.64 205 | -0.34 206 | -0.50 207 | -1.85 208 | -0.94 209 | -0.78 210 | 0.29 211 | 0.27 212 | 0.69 213 | -0.06 214 | -0.83 215 | -0.80 216 | -1.02 217 | -0.96 218 | -0.09 219 | 0.62 220 | 0.87 221 | 1.03 222 | 0.70 223 | -0.10 224 | -0.31 225 | 0.04 226 | -0.46 227 | 0.04 228 | 0.24 229 | -0.08 230 | -0.28 231 | 0.06 232 | 0.05 233 | -0.31 234 | 0.11 235 | 0.27 236 | 0.26 237 | 0.04 238 | 0.12 239 | 1.11 240 | 1.53 241 | 1.23 242 | 0.17 243 | -0.18 244 | -0.56 245 | 0.05 246 | 0.41 247 | 0.22 248 | 0.04 249 | -0.19 250 | -0.46 251 | -0.65 252 | -1.06 253 | -0.54 254 | 0.14 255 | 0.25 256 | -0.21 257 | -0.73 258 | -0.43 259 | 0.48 260 | 0.26 261 | 0.05 262 | 0.11 263 | -0.27 264 | -0.08 265 | -0.10 266 | 0.29 267 | -0.15 268 | -0.28 269 | -0.55 270 | -0.44 271 | -1.40 272 | -0.55 273 | -0.69 274 | 0.58 275 | 0.37 276 | 0.42 277 | 1.83 278 | 1.23 279 | 0.65 280 | 0.41 281 | 1.03 282 | 0.64 283 | -0.07 284 | 0.98 285 | 0.36 286 | -0.30 287 | -1.33 288 | -1.39 289 | -0.94 290 | 0.34 291 | -0.00 292 | -0.15 293 | 0.06 294 | 0.39 295 | 0.36 296 | -0.49 297 | -0.53 298 | 0.35 299 | 0.07 300 | -0.24 301 | 0.20 302 | -0.22 303 | -0.68 304 | -0.44 305 | 0.02 306 | -0.22 307 | -0.30 308 | -0.59 309 | 0.10 310 | -0.02 311 | -0.27 312 | -0.60 313 | -0.48 314 | -0.37 315 | -0.53 316 | -1.35 317 | -1.22 318 | -0.99 319 | -0.34 320 | -0.79 321 | -0.24 322 | 0.02 323 | 0.69 324 | 0.78 325 | 0.17 326 | -0.17 327 | -0.29 328 | -0.27 329 | 0.31 330 | 0.44 331 | 0.38 332 | 0.24 333 | -0.13 334 | -0.89 335 | -0.76 336 | -0.71 337 | -0.37 338 | -0.59 339 | -0.63 340 | -1.47 341 | -0.40 342 | -0.18 343 | -0.37 344 | -0.43 345 | -0.06 346 | 0.61 347 | 1.33 348 | 1.19 349 | 1.13 350 | 0.31 351 | 0.14 352 | 0.03 353 | 0.21 354 | 0.15 355 | -0.22 356 | -0.02 357 | 0.03 358 | -0.17 359 | 0.12 360 | -0.35 361 | -0.06 362 | 0.38 363 | -0.45 364 | -0.32 365 | -0.33 366 | -0.49 367 | -0.14 368 | -0.56 369 | -0.18 370 | 0.46 371 | 1.09 372 | 1.04 373 | 0.23 374 | -0.99 375 | -0.59 376 | -0.92 377 | -0.28 378 | 0.52 379 | 1.31 380 | 1.45 381 | 0.61 382 | -0.11 383 | -0.18 384 | -0.39 385 | -0.39 386 | -0.36 387 | -0.50 388 | -0.81 389 | -1.10 390 | -0.29 391 | 0.57 392 | 0.68 393 | 0.78 394 | 0.78 395 | 0.63 396 | 0.98 397 | 0.49 398 | -0.42 399 | -1.34 400 | -1.20 401 | -1.18 402 | -0.65 403 | -0.42 404 | -0.97 405 | -0.28 406 | 0.77 407 | 1.77 408 | 2.22 409 | 1.05 410 | -0.67 411 | -0.99 412 | -1.52 413 | -1.17 414 | -0.22 415 | -0.04 416 | -0.45 417 | -0.46 418 | -0.75 419 | -0.70 420 | -1.38 421 | -1.15 422 | -0.01 423 | 0.97 424 | 1.10 425 | 0.68 426 | -0.02 427 | -0.04 428 | 0.47 429 | 0.30 430 | -0.55 431 | -0.51 432 | -0.09 433 | -0.01 434 | 0.34 435 | 0.61 436 | 0.58 437 | 0.33 438 | 0.38 439 | 0.10 440 | 0.18 441 | -0.30 442 | -0.06 443 | -0.28 444 | 0.12 445 | 0.58 446 | 0.89 447 | 0.93 448 | 2.39 449 | 2.44 450 | 1.92 451 | 0.64 452 | -0.24 453 | 0.27 454 | -0.13 455 | -0.16 456 | -0.54 457 | -0.13 458 | -0.37 459 | -0.78 460 | -0.22 461 | 0.03 462 | 0.25 463 | 0.31 464 | 1.03 465 | 1.10 466 | 1.05 467 | 1.11 468 | 1.28 469 | 0.57 470 | -0.55 471 | -1.16 472 | -0.99 473 | -0.38 474 | 0.01 475 | -0.29 476 | 0.09 477 | 0.46 478 | 0.57 479 | 0.24 480 | 0.39 481 | 0.49 482 | 0.86 483 | 0.51 484 | 0.95 485 | 1.25 486 | 1.33 487 | -0.00 488 | 0.34 489 | 0.66 490 | 1.11 491 | 0.34 492 | 0.48 493 | 0.56 494 | 0.39 495 | -0.17 496 | 1.04 497 | 0.77 498 | 0.12 499 | -0.35 500 | -0.22 501 | 0.08 502 | -0.08 503 | -0.18 504 | -0.06 505 | -------------------------------------------------------------------------------- /lib/wavelib/src/wtmath.c: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2014, Rafat Hussain 3 | */ 4 | #include "wtmath.h" 5 | 6 | int upsamp(double *x, int lenx, int M, double *y) { 7 | int N, i, j, k; 8 | 9 | if (M < 0) { 10 | return -1; 11 | } 12 | 13 | if (M == 0) { 14 | for (i = 0; i < lenx; ++i) { 15 | y[i] = x[i]; 16 | } 17 | return lenx; 18 | } 19 | 20 | N = M * (lenx - 1) + 1; 21 | j = 1; 22 | k = 0; 23 | 24 | for (i = 0; i < N; ++i) { 25 | j--; 26 | y[i] = 0.0; 27 | if (j == 0) { 28 | y[i] = x[k]; 29 | k++; 30 | j = M; 31 | } 32 | } 33 | 34 | return N; 35 | } 36 | 37 | int upsamp2(double *x, int lenx, int M, double *y) { 38 | int N, i, j, k; 39 | // upsamp2 returns even numbered output. Last value is set to zero 40 | if (M < 0) { 41 | return -1; 42 | } 43 | 44 | if (M == 0) { 45 | for (i = 0; i < lenx; ++i) { 46 | y[i] = x[i]; 47 | } 48 | return lenx; 49 | } 50 | 51 | N = M * lenx; 52 | j = 1; 53 | k = 0; 54 | 55 | for (i = 0; i < N; ++i) { 56 | j--; 57 | y[i] = 0.0; 58 | if (j == 0) { 59 | y[i] = x[k]; 60 | k++; 61 | j = M; 62 | } 63 | } 64 | 65 | return N; 66 | } 67 | 68 | int downsamp(double *x, int lenx, int M, double *y) { 69 | int N, i; 70 | 71 | if (M < 0) { 72 | return -1; 73 | } 74 | if (M == 0) { 75 | for (i = 0; i < lenx; ++i) { 76 | y[i] = x[i]; 77 | } 78 | return lenx; 79 | } 80 | 81 | N = (lenx - 1) / M + 1; 82 | 83 | for (i = 0; i < N; ++i) { 84 | y[i] = x[i*M]; 85 | } 86 | 87 | return N; 88 | } 89 | /* 90 | int per_ext(double *sig, int len, int a,double *oup) { 91 | int i,len2; 92 | // oup is of length len + (len%2) + 2 * a 93 | for (i = 0; i < len; ++i) { 94 | oup[a + i] = sig[i]; 95 | } 96 | len2 = len; 97 | if ((len % 2) != 0) { 98 | len2 = len + 1; 99 | oup[a + len] = sig[len - 1]; 100 | } 101 | for (i = 0; i < a; ++i) { 102 | oup[a-1-i] = sig[len - 1 - i]; 103 | oup[len2 + a + i] = sig[i]; 104 | } 105 | 106 | return len2; 107 | 108 | } 109 | */ 110 | 111 | int per_ext(double *sig, int len, int a, double *oup) { 112 | int i, len2; 113 | double temp1; 114 | double temp2; 115 | for (i = 0; i < len; ++i) { 116 | oup[a + i] = sig[i]; 117 | } 118 | len2 = len; 119 | if ((len % 2) != 0) { 120 | len2 = len + 1; 121 | oup[a + len] = sig[len - 1]; 122 | } 123 | for (i = 0; i < a; ++i) { 124 | temp1 = oup[a + i]; 125 | temp2 = oup[a + len2 - 1 - i]; 126 | oup[a - 1 - i] = temp2; 127 | oup[len2 + a + i] = temp1; 128 | } 129 | return len2; 130 | } 131 | /* 132 | int symm_ext(double *sig, int len, int a, double *oup) { 133 | int i, len2; 134 | // oup is of length len + 2 * a 135 | for (i = 0; i < len; ++i) { 136 | oup[a + i] = sig[i]; 137 | } 138 | len2 = len; 139 | for (i = 0; i < a; ++i) { 140 | oup[a - 1 - i] = sig[i]; 141 | oup[len2 + a + i] = sig[len - 1 - i]; 142 | } 143 | 144 | return len2; 145 | 146 | } 147 | */ 148 | 149 | int symm_ext(double *sig, int len, int a, double *oup) { 150 | int i, len2; 151 | double temp1; 152 | double temp2; 153 | // oup is of length len + 2 * a 154 | for (i = 0; i < len; ++i) { 155 | oup[a + i] = sig[i]; 156 | } 157 | len2 = len; 158 | for (i = 0; i < a; ++i) { 159 | temp1 = oup[a + i]; 160 | temp2 = oup[a + len2 - 1 - i]; 161 | oup[a - 1 - i] = temp1; 162 | oup[len2 + a + i] = temp2; 163 | } 164 | 165 | return len2; 166 | 167 | } 168 | 169 | static int isign(int N) { 170 | int M; 171 | if (N >= 0) { 172 | M = 1; 173 | } 174 | else { 175 | M = -1; 176 | } 177 | 178 | return M; 179 | } 180 | 181 | static int iabs(int N) { 182 | if (N >= 0) { 183 | return N; 184 | } 185 | else { 186 | return -N; 187 | } 188 | } 189 | 190 | void circshift(double *array, int N, int L) { 191 | int i; 192 | double *temp; 193 | if (iabs(L) > N) { 194 | L = isign(L) * (iabs(L) % N); 195 | } 196 | if (L < 0) { 197 | L = (N + L) % N; 198 | } 199 | 200 | temp = (double*)malloc(sizeof(double) * L); 201 | 202 | for (i = 0; i < L; ++i) { 203 | temp[i] = array[i]; 204 | } 205 | 206 | for (i = 0; i < N - L; ++i) { 207 | array[i] = array[i + L]; 208 | } 209 | 210 | for (i = 0; i < L; ++i) { 211 | array[N - L + i] = temp[i]; 212 | } 213 | 214 | free(temp); 215 | } 216 | 217 | int testSWTlength(int N, int J) { 218 | int ret,div,i; 219 | ret = 1; 220 | 221 | div = 1; 222 | for (i = 0; i < J; ++i) { 223 | div *= 2; 224 | } 225 | 226 | if (N % div) { 227 | ret = 0; 228 | } 229 | 230 | return ret; 231 | 232 | } 233 | 234 | int wmaxiter(int sig_len, int filt_len) { 235 | int lev; 236 | double temp; 237 | 238 | temp = log((double)sig_len / ((double)filt_len - 1.0)) / log(2.0); 239 | lev = (int)temp; 240 | 241 | return lev; 242 | } 243 | 244 | static double entropy_s(double *x,int N) { 245 | int i; 246 | double val,x2; 247 | 248 | val = 0.0; 249 | 250 | for(i = 0; i < N; ++i) { 251 | if (x[i] != 0) { 252 | x2 = x[i] * x[i]; 253 | val -= x2 * log(x2); 254 | } 255 | } 256 | return val; 257 | } 258 | 259 | static double entropy_t(double *x,int N, double t) { 260 | int i; 261 | double val,x2; 262 | if (t < 0) { 263 | printf("Threshold value must be >= 0"); 264 | exit(1); 265 | } 266 | val = 0.0; 267 | 268 | for(i = 0; i < N; ++i) { 269 | x2 = fabs(x[i]); 270 | if (x2 > t) { 271 | val += 1; 272 | } 273 | 274 | } 275 | 276 | return val; 277 | 278 | } 279 | 280 | static double entropy_n(double *x,int N,double p) { 281 | int i; 282 | double val,x2; 283 | if (p < 1) { 284 | printf("Norm power value must be >= 1"); 285 | exit(1); 286 | } 287 | val = 0.0; 288 | for(i = 0; i < N; ++i) { 289 | x2 = fabs(x[i]); 290 | val += pow(x2,(double)p); 291 | 292 | } 293 | 294 | return val; 295 | } 296 | 297 | static double entropy_l(double *x,int N) { 298 | int i; 299 | double val,x2; 300 | 301 | val = 0.0; 302 | 303 | for(i = 0; i < N; ++i) { 304 | if (x[i] != 0) { 305 | x2 = x[i] * x[i]; 306 | val += log(x2); 307 | } 308 | } 309 | return val; 310 | } 311 | 312 | double costfunc(double *x, int N ,char *entropy,double p) { 313 | double val; 314 | 315 | if (!strcmp(entropy, "shannon")) { 316 | val = entropy_s(x, N); 317 | } 318 | else if (!strcmp(entropy, "threshold")) { 319 | val = entropy_t(x, N,p); 320 | } 321 | else if (!strcmp(entropy, "norm")) { 322 | val = entropy_n(x, N,p); 323 | } 324 | else if (!strcmp(entropy, "logenergy") || !strcmp(entropy, "log energy") || !strcmp(entropy, "energy")) { 325 | val = entropy_l(x, N); 326 | } 327 | else { 328 | printf("Entropy must be one of shannon, threshold, norm or energy"); 329 | exit(-1); 330 | } 331 | 332 | return val; 333 | } 334 | -------------------------------------------------------------------------------- /lib/wavelib/src/wavelib.h: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2014, Rafat Hussain 3 | */ 4 | #ifndef WAVELIB_H_ 5 | #define WAVELIB_H_ 6 | 7 | #include "wtmath.h" 8 | #include "cwt.h" 9 | 10 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | #if defined(_MSC_VER) 15 | #pragma warning(disable : 4200) 16 | #pragma warning(disable : 4996) 17 | #endif 18 | 19 | #ifndef cplx_type 20 | #define cplx_type double 21 | #endif 22 | 23 | 24 | typedef struct cplx_t { 25 | cplx_type re; 26 | cplx_type im; 27 | } cplx_data; 28 | 29 | typedef struct wave_set* wave_object; 30 | 31 | wave_object wave_init(char* wname); 32 | 33 | struct wave_set{ 34 | char wname[50]; 35 | int filtlength;// When all filters are of the same length. [Matlab uses zero-padding to make all filters of the same length] 36 | int lpd_len;// Default filtlength = lpd_len = lpr_len = hpd_len = hpr_len 37 | int hpd_len; 38 | int lpr_len; 39 | int hpr_len; 40 | double *lpd; 41 | double *hpd; 42 | double *lpr; 43 | double *hpr; 44 | double params[0]; 45 | }; 46 | 47 | typedef struct wt_set* wt_object; 48 | 49 | wt_object wt_init(wave_object wave,char* method, int siglength, int J); 50 | 51 | struct wt_set{ 52 | wave_object wave; 53 | conv_object cobj; 54 | char method[10]; 55 | int siglength;// Length of the original signal. 56 | int outlength;// Length of the output DWT vector 57 | int lenlength;// Length of the Output Dimension Vector "length" 58 | int J; // Number of decomposition Levels 59 | int MaxIter;// Maximum Iterations J <= MaxIter 60 | int even;// even = 1 if signal is of even length. even = 0 otherwise 61 | char ext[10];// Type of Extension used - "per" or "sym" 62 | char cmethod[10]; // Convolution Method - "direct" or "FFT" 63 | 64 | int N; // 65 | int cfftset; 66 | int zpad; 67 | int length[102]; 68 | double *output; 69 | double params[0]; 70 | }; 71 | 72 | typedef struct wtree_set* wtree_object; 73 | 74 | wtree_object wtree_init(wave_object wave, int siglength, int J); 75 | 76 | struct wtree_set{ 77 | wave_object wave; 78 | conv_object cobj; 79 | char method[10]; 80 | int siglength;// Length of the original signal. 81 | int outlength;// Length of the output DWT vector 82 | int lenlength;// Length of the Output Dimension Vector "length" 83 | int J; // Number of decomposition Levels 84 | int MaxIter;// Maximum Iterations J <= MaxIter 85 | int even;// even = 1 if signal is of even length. even = 0 otherwise 86 | char ext[10];// Type of Extension used - "per" or "sym" 87 | 88 | int N; // 89 | int nodes; 90 | int cfftset; 91 | int zpad; 92 | int length[102]; 93 | double *output; 94 | int *nodelength; 95 | int *coeflength; 96 | double params[0]; 97 | }; 98 | 99 | typedef struct wpt_set* wpt_object; 100 | 101 | wpt_object wpt_init(wave_object wave, int siglength, int J); 102 | 103 | struct wpt_set{ 104 | wave_object wave; 105 | conv_object cobj; 106 | int siglength;// Length of the original signal. 107 | int outlength;// Length of the output DWT vector 108 | int lenlength;// Length of the Output Dimension Vector "length" 109 | int J; // Number of decomposition Levels 110 | int MaxIter;// Maximum Iterations J <= MaxIter 111 | int even;// even = 1 if signal is of even length. even = 0 otherwise 112 | char ext[10];// Type of Extension used - "per" or "sym" 113 | char entropy[20]; 114 | double eparam; 115 | 116 | int N; // 117 | int nodes; 118 | int length[102]; 119 | double *output; 120 | double *costvalues; 121 | double *basisvector; 122 | int *nodeindex; 123 | int *numnodeslevel; 124 | int *coeflength; 125 | double params[0]; 126 | }; 127 | 128 | typedef struct cwt_set* cwt_object; 129 | 130 | cwt_object cwt_init(const char* const wave, double param, int siglength,double dt, int J); 131 | 132 | struct cwt_set{ 133 | char wave[10];// Wavelet - morl/morlet,paul,dog/dgauss 134 | int siglength;// Length of Input Data 135 | int J;// Total Number of Scales 136 | double s0;// Smallest scale. It depends on the sampling rate. s0 <= 2 * dt for most wavelets 137 | double dt;// Sampling Rate 138 | double dj;// Separation between scales. eg., scale = s0 * 2 ^ ( [0:N-1] *dj ) or scale = s0 *[0:N-1] * dj 139 | char type[10];// Scale Type - Power or Linear 140 | int pow;// Base of Power in case type = pow. Typical value is pow = 2 141 | int sflag; 142 | int pflag; 143 | int npad; 144 | int mother; 145 | double m;// Wavelet parameter param 146 | double smean;// Input Signal mean 147 | 148 | cplx_data *output; 149 | double *scale; 150 | double *period; 151 | double *coi; 152 | double params[0]; 153 | }; 154 | 155 | 156 | void dwt(wt_object wt, double *inp); 157 | 158 | void idwt(wt_object wt, double *dwtop); 159 | 160 | void wtree(wtree_object wt, double *inp); 161 | 162 | void dwpt(wpt_object wt, double *inp); 163 | 164 | void idwpt(wpt_object wt, double *dwtop); 165 | 166 | void swt(wt_object wt, double *inp); 167 | 168 | void iswt(wt_object wt, double *swtop); 169 | 170 | void modwt(wt_object wt, double *inp); 171 | 172 | void imodwt(wt_object wt, double *dwtop); 173 | 174 | void setDWTExtension(wt_object wt, char *extension); 175 | 176 | void setWTREEExtension(wtree_object wt, char *extension); 177 | 178 | void setDWPTExtension(wpt_object wt, char *extension); 179 | 180 | void setDWPTEntropy(wpt_object wt, char *entropy, double eparam); 181 | 182 | void setWTConv(wt_object wt, char *cmethod); 183 | 184 | int getWTREENodelength(wtree_object wt, int X); 185 | 186 | void getWTREECoeffs(wtree_object wt, int X, int Y, double *coeffs, int N); 187 | 188 | int getDWPTNodelength(wpt_object wt, int X); 189 | 190 | void getDWPTCoeffs(wpt_object wt, int X, int Y, double *coeffs, int N); 191 | 192 | void setCWTScales(cwt_object wt, double s0, double dj, const char *type, int power); 193 | 194 | void setCWTScaleVector(cwt_object wt, double *scale, int J, double s0, double dj); 195 | 196 | void setCWTPadding(cwt_object wt, int pad); 197 | 198 | void cwt(cwt_object wt, const double *inp); 199 | 200 | void icwt(cwt_object wt, double *cwtop); 201 | 202 | int getCWTScaleLength(int N); 203 | 204 | void wave_summary(wave_object obj); 205 | 206 | void wt_summary(wt_object wt); 207 | 208 | void wtree_summary(wtree_object wt); 209 | 210 | void wpt_summary(wpt_object wt); 211 | 212 | void cwt_summary(cwt_object wt); 213 | 214 | void wave_free(wave_object object); 215 | 216 | void wt_free(wt_object object); 217 | 218 | void wtree_free(wtree_object object); 219 | 220 | void wpt_free(wpt_object object); 221 | 222 | void cwt_free(cwt_object object); 223 | 224 | 225 | #ifdef __cplusplus 226 | } 227 | #endif 228 | 229 | 230 | #endif /* WAVELIB_H_ */ 231 | -------------------------------------------------------------------------------- /lib/wavelib/header/wavelib.h: -------------------------------------------------------------------------------- 1 | #ifndef WAVELIB_H_ 2 | #define WAVELIB_H_ 3 | 4 | #ifdef __cplusplus 5 | extern "C" { 6 | #endif 7 | 8 | #if defined(_MSC_VER) 9 | #pragma warning(disable : 4200) 10 | #pragma warning(disable : 4996) 11 | #endif 12 | 13 | #ifndef fft_type 14 | #define fft_type double 15 | #endif 16 | 17 | #ifndef cplx_type 18 | #define cplx_type double 19 | #endif 20 | 21 | 22 | typedef struct cplx_t { 23 | cplx_type re; 24 | cplx_type im; 25 | } cplx_data; 26 | 27 | typedef struct wave_set* wave_object; 28 | 29 | wave_object wave_init(char* wname); 30 | 31 | struct wave_set{ 32 | char wname[50]; 33 | int filtlength;// When all filters are of the same length. [Matlab uses zero-padding to make all filters of the same length] 34 | int lpd_len;// Default filtlength = lpd_len = lpr_len = hpd_len = hpr_len 35 | int hpd_len; 36 | int lpr_len; 37 | int hpr_len; 38 | double *lpd; 39 | double *hpd; 40 | double *lpr; 41 | double *hpr; 42 | double params[0]; 43 | }; 44 | 45 | typedef struct fft_t { 46 | fft_type re; 47 | fft_type im; 48 | } fft_data; 49 | 50 | typedef struct fft_set* fft_object; 51 | 52 | fft_object fft_init(int N, int sgn); 53 | 54 | struct fft_set{ 55 | int N; 56 | int sgn; 57 | int factors[64]; 58 | int lf; 59 | int lt; 60 | fft_data twiddle[1]; 61 | }; 62 | 63 | typedef struct fft_real_set* fft_real_object; 64 | 65 | fft_real_object fft_real_init(int N, int sgn); 66 | 67 | struct fft_real_set{ 68 | fft_object cobj; 69 | fft_data twiddle2[1]; 70 | }; 71 | 72 | typedef struct conv_set* conv_object; 73 | 74 | conv_object conv_init(int N, int L); 75 | 76 | struct conv_set{ 77 | fft_real_object fobj; 78 | fft_real_object iobj; 79 | int ilen1; 80 | int ilen2; 81 | int clen; 82 | }; 83 | 84 | typedef struct wt_set* wt_object; 85 | 86 | wt_object wt_init(wave_object wave,char* method, int siglength, int J); 87 | 88 | struct wt_set{ 89 | wave_object wave; 90 | conv_object cobj; 91 | char method[10]; 92 | int siglength;// Length of the original signal. 93 | int outlength;// Length of the output DWT vector 94 | int lenlength;// Length of the Output Dimension Vector "length" 95 | int J; // Number of decomposition Levels 96 | int MaxIter;// Maximum Iterations J <= MaxIter 97 | int even;// even = 1 if signal is of even length. even = 0 otherwise 98 | char ext[10];// Type of Extension used - "per" or "sym" 99 | char cmethod[10]; // Convolution Method - "direct" or "FFT" 100 | 101 | int N; // 102 | int cfftset; 103 | int zpad; 104 | int length[102]; 105 | double *output; 106 | double params[0]; 107 | }; 108 | 109 | typedef struct wtree_set* wtree_object; 110 | 111 | wtree_object wtree_init(wave_object wave, int siglength, int J); 112 | 113 | struct wtree_set{ 114 | wave_object wave; 115 | conv_object cobj; 116 | char method[10]; 117 | int siglength;// Length of the original signal. 118 | int outlength;// Length of the output DWT vector 119 | int lenlength;// Length of the Output Dimension Vector "length" 120 | int J; // Number of decomposition Levels 121 | int MaxIter;// Maximum Iterations J <= MaxIter 122 | int even;// even = 1 if signal is of even length. even = 0 otherwise 123 | char ext[10];// Type of Extension used - "per" or "sym" 124 | 125 | int N; // 126 | int nodes; 127 | int cfftset; 128 | int zpad; 129 | int length[102]; 130 | double *output; 131 | int *nodelength; 132 | int *coeflength; 133 | double params[0]; 134 | }; 135 | 136 | typedef struct wpt_set* wpt_object; 137 | 138 | wpt_object wpt_init(wave_object wave, int siglength, int J); 139 | 140 | struct wpt_set{ 141 | wave_object wave; 142 | conv_object cobj; 143 | int siglength;// Length of the original signal. 144 | int outlength;// Length of the output DWT vector 145 | int lenlength;// Length of the Output Dimension Vector "length" 146 | int J; // Number of decomposition Levels 147 | int MaxIter;// Maximum Iterations J <= MaxIter 148 | int even;// even = 1 if signal is of even length. even = 0 otherwise 149 | char ext[10];// Type of Extension used - "per" or "sym" 150 | char entropy[20]; 151 | double eparam; 152 | 153 | int N; // 154 | int nodes; 155 | int length[102]; 156 | double *output; 157 | double *costvalues; 158 | double *basisvector; 159 | int *nodeindex; 160 | int *numnodeslevel; 161 | int *coeflength; 162 | double params[0]; 163 | }; 164 | 165 | 166 | typedef struct cwt_set* cwt_object; 167 | 168 | cwt_object cwt_init(char* wave, double param, int siglength,double dt, int J); 169 | 170 | struct cwt_set{ 171 | char wave[10];// Wavelet - morl/morlet,paul,dog/dgauss 172 | int siglength;// Length of Input Data 173 | int J;// Total Number of Scales 174 | double s0;// Smallest scale. It depends on the sampling rate. s0 <= 2 * dt for most wavelets 175 | double dt;// Sampling Rate 176 | double dj;// Separation between scales. eg., scale = s0 * 2 ^ ( [0:N-1] *dj ) or scale = s0 *[0:N-1] * dj 177 | char type[10];// Scale Type - Power or Linear 178 | int pow;// Base of Power in case type = pow. Typical value is pow = 2 179 | int sflag; 180 | int pflag; 181 | int npad; 182 | int mother; 183 | double m;// Wavelet parameter param 184 | double smean;// Input Signal mean 185 | 186 | cplx_data *output; 187 | double *scale; 188 | double *period; 189 | double *coi; 190 | double params[0]; 191 | }; 192 | 193 | 194 | void dwt(wt_object wt, double *inp); 195 | 196 | void idwt(wt_object wt, double *dwtop); 197 | 198 | void wtree(wtree_object wt, double *inp); 199 | 200 | void dwpt(wpt_object wt, double *inp); 201 | 202 | void idwpt(wpt_object wt, double *dwtop); 203 | 204 | void swt(wt_object wt, double *inp); 205 | 206 | void iswt(wt_object wt, double *swtop); 207 | 208 | void modwt(wt_object wt, double *inp); 209 | 210 | void imodwt(wt_object wt, double *dwtop); 211 | 212 | void setDWTExtension(wt_object wt, char *extension); 213 | 214 | void setWTREEExtension(wtree_object wt, char *extension); 215 | 216 | void setDWPTExtension(wpt_object wt, char *extension); 217 | 218 | void setDWPTEntropy(wpt_object wt, char *entropy, double eparam); 219 | 220 | void setWTConv(wt_object wt, char *cmethod); 221 | 222 | int getWTREENodelength(wtree_object wt, int X); 223 | 224 | void getWTREECoeffs(wtree_object wt, int X, int Y, double *coeffs, int N); 225 | 226 | int getDWPTNodelength(wpt_object wt, int X); 227 | 228 | void getDWPTCoeffs(wpt_object wt, int X, int Y, double *coeffs, int N); 229 | 230 | void setCWTScales(cwt_object wt, double s0, double dj, const char *type, int power); 231 | 232 | void setCWTScaleVector(cwt_object wt, double *scale, int J, double s0, double dj); 233 | 234 | void setCWTPadding(cwt_object wt, int pad); 235 | 236 | void cwt(cwt_object wt, const double *inp); 237 | 238 | void icwt(cwt_object wt, double *cwtop); 239 | 240 | int getCWTScaleLength(int N); 241 | 242 | void wave_summary(wave_object obj); 243 | 244 | void wt_summary(wt_object wt); 245 | 246 | void wtree_summary(wtree_object wt); 247 | 248 | void wpt_summary(wpt_object wt); 249 | 250 | void cwt_summary(cwt_object wt);; 251 | 252 | void wave_free(wave_object object); 253 | 254 | void wt_free(wt_object object); 255 | 256 | void wtree_free(wtree_object object); 257 | 258 | void wpt_free(wpt_object object); 259 | 260 | void cwt_free(cwt_object object); 261 | 262 | 263 | #ifdef __cplusplus 264 | } 265 | #endif 266 | 267 | 268 | #endif /* WAVELIB_H_ */ 269 | -------------------------------------------------------------------------------- /src/main/opts.h: -------------------------------------------------------------------------------- 1 | #ifndef OPTS_H__ 2 | #define OPTS_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | extern "C" { 8 | #include 9 | } 10 | #include "util/exception.h" 11 | 12 | struct options { 13 | //-> required parameter 14 | char input[65532]; 15 | char peer[65532]; 16 | char output[65532]; 17 | //-> key parameter 18 | int radius; 19 | int level; 20 | float scale0; 21 | //-> vice parameter 22 | int verbose; 23 | int test; 24 | int mode; 25 | }; 26 | 27 | inline int GetOpts(int argc, char **argv, options* opts_) { 28 | 29 | static struct option longopts[] = { 30 | { "help", no_argument, NULL, 'h' }, 31 | { "input", required_argument, NULL, 'i' }, 32 | { "peer", required_argument, NULL, 'p' }, 33 | { "output", required_argument, NULL, 'o' }, 34 | { "radius", required_argument, NULL, 'r' }, 35 | { "level", required_argument, NULL, 'l' }, 36 | { "scale", required_argument, NULL, 's' }, 37 | { "verbose", no_argument, NULL, 'v' }, 38 | { "test", no_argument, NULL, 't' }, 39 | { "mode", no_argument, NULL, 'm' }, 40 | { NULL, 0, NULL, 0 } 41 | }; 42 | 43 | if((argc !=5 && argc != 7 && argc != 9 && argc != 11 && argc != 13 && argc != 15 && argc != 17 && argc != 19 ) && argc >= 3 || (argc == 2 && argv[1][0] != '-' && argv[1][1] != 'h') || argc == 1) { 44 | 45 | EX_TRACE("\n"); 46 | EX_TRACE(" ___ _____ _ _ _ \n"); 47 | EX_TRACE(" ___ _ _ _| \\_ _/ | | \\ \n"); 48 | EX_TRACE("| _| | | | | | | | | | | | \n"); 49 | EX_TRACE("|___|_____|___/ |_| |_____| \n"); 50 | EX_TRACE("\n"); 51 | EX_TRACE("version v0.03 (OCT 22 2017) \n"); 52 | EX_TRACE("-------------------------------------------------------------\n"); 53 | EX_TRACE("required:\n"); 54 | EX_TRACE("[-i SHORT SIGNAL][-p LONG SIGNAL][-o OUTPUT] \n"); 55 | EX_TRACE("optional:\n"); 56 | EX_TRACE("([-r RADIUS])([-l LEVEL])([-s SCALE])\n"); 57 | // EX_TRACE("([-v verbose])([-t test])([-m mode]) \n"); 58 | EX_TRACE("-------------------------------------------------------------\n"); 59 | EX_TRACE("[note]: by default, r=50, l=3, s=sqrt(2) \n"); 60 | // EX_TRACE("[note]: by default, r=50, l=3, s=sqrt(2), v=0, t=0, m=0 \n"); 61 | EX_TRACE(" for more detailed description, type '-h' \n"); 62 | return -1; 63 | } 64 | 65 | int ch; 66 | while((ch = getopt_long(argc, argv, "hi:p:o:r:l:s:v:t:m:", longopts, NULL))!= -1) { 67 | switch(ch) { 68 | 69 | case '?': 70 | { 71 | EX_TRACE("Invalid option '%s'.", argv[optind-1]); 72 | return -1; 73 | } 74 | 75 | case ':': 76 | { 77 | EX_TRACE("Missing option argument for '%s'.", argv[optind-1]); 78 | return -1; 79 | } 80 | 81 | case 'h': 82 | { 83 | EX_TRACE("----------- cwDTW ---------- \n" 84 | "version v0.03 (OCT 22 2017) \n" 85 | "-------------------------------------------------------------\n" 86 | "required:\n" 87 | "[-i SHORT SIGNAL][-p LONG SIGNAL][-o OUTPUT]\n" 88 | "optional:\n" 89 | "([-r RADIUS])([-l LEVEL])([-s SCALE]) \n" 90 | // "([-v verbose])([-t test])([-m mode]) \n" 91 | "-------------------------------------------------------------\n" 92 | "**** required: ******\n" 93 | "SHORT SIGNALE: (reference) sequence signal from ATCG...;\n" 94 | "LONG SIGNAL: (nanopore) raw electrical current signal;\n" 95 | "OUTPUT: signal mapping result; if not specified, then no output be generated; \n" 96 | "**** key parameters: ******\n" 97 | "RADIUS: warp search radius (default 50);\n" 98 | "LEVEL: sampling level in continous wavelet (default 3);\n" 99 | "SCALE: base scale in continous wavelet (default sqrt(2));\n"); 100 | // "**** vice parameters: ******\n" 101 | // "verbose: 0 for NO screenout message, 1 for screenout (default 0);\n" 102 | // "test: test mode. 0 not_use; 1 equal_ave; 2 peak_ave; 3 FastDTW (default 0) \n" 103 | // "mode: bound mode. 0 block_mode; 1 diagonol_mode (default 0) \n" 104 | return -1; 105 | } 106 | 107 | case 'i': 108 | { 109 | std::istringstream iss(optarg); 110 | iss >> opts_->input; 111 | if(iss.fail()){ 112 | EX_TRACE("Invalid argument '%s'.", optarg); 113 | return -1; 114 | } 115 | } 116 | break; 117 | 118 | case 'p': 119 | { 120 | std::istringstream iss(optarg); 121 | iss >> opts_->peer; 122 | if(iss.fail()){ 123 | EX_TRACE("Invalid argument '%s'.", optarg); 124 | return -1; 125 | } 126 | } 127 | break; 128 | 129 | case 'o': 130 | { 131 | std::istringstream iss(optarg); 132 | iss >> opts_->output; 133 | if(iss.fail()){ 134 | EX_TRACE("Invalid argument '%s'.", optarg); 135 | return -1; 136 | } 137 | } 138 | break; 139 | 140 | case 'r': 141 | { 142 | std::istringstream iss(optarg); 143 | iss >> opts_->radius; 144 | if(iss.fail()){ 145 | EX_TRACE("Invalid argument '%s'.", optarg); 146 | return -1; 147 | } 148 | } 149 | break; 150 | 151 | case 'l': 152 | { 153 | std::istringstream iss(optarg); 154 | iss >> opts_->level; 155 | if(iss.fail()){ 156 | EX_TRACE("Invalid argument '%s'.", optarg); 157 | return -1; 158 | } 159 | } 160 | break; 161 | 162 | case 's': 163 | { 164 | std::istringstream iss(optarg); 165 | iss >> opts_->scale0; 166 | if(iss.fail()){ 167 | EX_TRACE("Invalid argument '%s'.", optarg); 168 | return -1; 169 | } 170 | } 171 | break; 172 | 173 | case 'v': 174 | { 175 | std::istringstream iss(optarg); 176 | iss >> opts_->verbose; 177 | if(iss.fail()){ 178 | EX_TRACE("Invalid argument '%s'.", optarg); 179 | return -1; 180 | } 181 | } 182 | break; 183 | 184 | case 't': 185 | { 186 | std::istringstream iss(optarg); 187 | iss >> opts_->test; 188 | if(iss.fail()){ 189 | EX_TRACE("Invalid argument '%s'.", optarg); 190 | return -1; 191 | } 192 | } 193 | break; 194 | 195 | case 'm': 196 | { 197 | std::istringstream iss(optarg); 198 | iss >> opts_->mode; 199 | if(iss.fail()){ 200 | EX_TRACE("Invalid argument '%s'.", optarg); 201 | return -1; 202 | } 203 | } 204 | break; 205 | 206 | case 0: 207 | break; 208 | 209 | default: 210 | assert(false); 211 | } 212 | } 213 | return 1; 214 | } 215 | 216 | #endif 217 | 218 | -------------------------------------------------------------------------------- /lib/wavelib/src/cwtmath.c: -------------------------------------------------------------------------------- 1 | #include "cwtmath.h" 2 | 3 | static void nsfft_fd(fft_object obj, fft_data *inp, fft_data *oup,double lb,double ub,double *w) { 4 | int M,N,i,j,L; 5 | double delta,den,theta,tempr,tempi,plb; 6 | double *temp1,*temp2; 7 | 8 | N = obj->N; 9 | L = N/2; 10 | //w = (double*)malloc(sizeof(double)*N); 11 | 12 | M = divideby(N, 2); 13 | 14 | if (M == 0) { 15 | printf("The Non-Standard FFT Length must be a power of 2"); 16 | exit(1); 17 | } 18 | 19 | temp1 = (double*)malloc(sizeof(double)*L); 20 | temp2 = (double*)malloc(sizeof(double)*L); 21 | 22 | delta = (ub - lb)/ N; 23 | j = -N; 24 | den = 2 * (ub-lb); 25 | 26 | for(i = 0; i < N;++i) { 27 | w[i] = (double)j/den; 28 | j += 2; 29 | } 30 | 31 | fft_exec(obj,inp,oup); 32 | 33 | 34 | for (i = 0; i < L; ++i) { 35 | temp1[i] = oup[i].re; 36 | temp2[i] = oup[i].im; 37 | } 38 | 39 | for (i = 0; i < N - L; ++i) { 40 | oup[i].re = oup[i + L].re; 41 | oup[i].im = oup[i + L].im; 42 | } 43 | 44 | for (i = 0; i < L; ++i) { 45 | oup[N - L + i].re = temp1[i]; 46 | oup[N - L + i].im = temp2[i]; 47 | } 48 | 49 | plb = PI2 * lb; 50 | 51 | for(i = 0; i < N;++i) { 52 | tempr = oup[i].re; 53 | tempi = oup[i].im; 54 | theta = w[i] * plb; 55 | 56 | oup[i].re = delta * (tempr*cos(theta) + tempi*sin(theta)); 57 | oup[i].im = delta * (tempi*cos(theta) - tempr*sin(theta)); 58 | } 59 | 60 | 61 | //free(w); 62 | free(temp1); 63 | free(temp2); 64 | } 65 | 66 | static void nsfft_bk(fft_object obj, fft_data *inp, fft_data *oup,double lb,double ub,double *t) { 67 | int M,N,i,j,L; 68 | double *w; 69 | double delta,den,plb,theta; 70 | double *temp1,*temp2; 71 | fft_data *inpt; 72 | 73 | N = obj->N; 74 | L = N/2; 75 | 76 | M = divideby(N, 2); 77 | 78 | if (M == 0) { 79 | printf("The Non-Standard FFT Length must be a power of 2"); 80 | exit(1); 81 | } 82 | 83 | temp1 = (double*)malloc(sizeof(double)*L); 84 | temp2 = (double*)malloc(sizeof(double)*L); 85 | w = (double*)malloc(sizeof(double)*N); 86 | inpt = (fft_data*) malloc (sizeof(fft_data) * N); 87 | 88 | delta = (ub - lb)/ N; 89 | j = -N; 90 | den = 2 * (ub-lb); 91 | 92 | for(i = 0; i < N;++i) { 93 | w[i] = (double)j/den; 94 | j += 2; 95 | } 96 | 97 | plb = PI2 * lb; 98 | 99 | for(i = 0; i < N;++i) { 100 | theta = w[i] * plb; 101 | 102 | inpt[i].re = (inp[i].re*cos(theta) - inp[i].im*sin(theta))/delta; 103 | inpt[i].im = (inp[i].im*cos(theta) + inp[i].re*sin(theta))/delta; 104 | } 105 | 106 | for (i = 0; i < L; ++i) { 107 | temp1[i] = inpt[i].re; 108 | temp2[i] = inpt[i].im; 109 | } 110 | 111 | for (i = 0; i < N - L; ++i) { 112 | inpt[i].re = inpt[i + L].re; 113 | inpt[i].im = inpt[i + L].im; 114 | } 115 | 116 | for (i = 0; i < L; ++i) { 117 | inpt[N - L + i].re = temp1[i]; 118 | inpt[N - L + i].im = temp2[i]; 119 | } 120 | 121 | fft_exec(obj,inpt,oup); 122 | 123 | for(i = 0; i < N;++i) { 124 | t[i] = lb + i*delta; 125 | } 126 | 127 | free(w); 128 | free(temp1); 129 | free(temp2); 130 | free(inpt); 131 | } 132 | 133 | void nsfft_exec(fft_object obj, fft_data *inp, fft_data *oup,double lb,double ub,double *w) { 134 | if (obj->sgn == 1) { 135 | nsfft_fd(obj,inp,oup,lb,ub,w); 136 | } else if (obj->sgn == -1) { 137 | nsfft_bk(obj,inp,oup,lb,ub,w); 138 | } 139 | } 140 | 141 | static double fix(double x) { 142 | // Rounds to the integer nearest to zero 143 | if (x >= 0.) { 144 | return floor(x); 145 | } else { 146 | return ceil(x); 147 | } 148 | } 149 | 150 | int nint(double N) { 151 | int i; 152 | 153 | i = (int)(N + 0.49999); 154 | 155 | return i; 156 | } 157 | 158 | double gamma(double x) { 159 | /* 160 | * This C program code is based on W J Cody's fortran code. 161 | * http://www.netlib.org/specfun/gamma 162 | * 163 | * References: 164 | "An Overview of Software Development for Special Functions", 165 | W. J. Cody, Lecture Notes in Mathematics, 506, 166 | Numerical Analysis Dundee, 1975, G. A. Watson (ed.), 167 | Springer Verlag, Berlin, 1976. 168 | 169 | Computer Approximations, Hart, Et. Al., Wiley and sons, New York, 1968. 170 | */ 171 | 172 | // numerator and denominator coefficients for 1 <= x <= 2 173 | 174 | double y,oup,fact,sum,y2,yi,z,nsum,dsum; 175 | int swi,n,i; 176 | 177 | double spi = 0.9189385332046727417803297; 178 | double pi = 3.1415926535897932384626434; 179 | double xmax = 171.624e+0; 180 | double xinf = 1.79e308; 181 | double eps = 2.22e-16; 182 | double xninf = 1.79e-308; 183 | 184 | double num[8] = { -1.71618513886549492533811e+0, 185 | 2.47656508055759199108314e+1, 186 | -3.79804256470945635097577e+2, 187 | 6.29331155312818442661052e+2, 188 | 8.66966202790413211295064e+2, 189 | -3.14512729688483675254357e+4, 190 | -3.61444134186911729807069e+4, 191 | 6.64561438202405440627855e+4 }; 192 | 193 | double den[8] = { -3.08402300119738975254353e+1, 194 | 3.15350626979604161529144e+2, 195 | -1.01515636749021914166146e+3, 196 | -3.10777167157231109440444e+3, 197 | 2.25381184209801510330112e+4, 198 | 4.75584627752788110767815e+3, 199 | -1.34659959864969306392456e+5, 200 | -1.15132259675553483497211e+5 }; 201 | 202 | // Coefficients for Hart's Minimax approximation x >= 12 203 | 204 | 205 | double c[7] = { -1.910444077728e-03, 206 | 8.4171387781295e-04, 207 | -5.952379913043012e-04, 208 | 7.93650793500350248e-04, 209 | -2.777777777777681622553e-03, 210 | 8.333333333333333331554247e-02, 211 | 5.7083835261e-03 }; 212 | 213 | y = x; 214 | swi = 0; 215 | fact = 1.0; 216 | n = 0; 217 | 218 | 219 | if ( y < 0.) { 220 | // Negative x 221 | y = -x; 222 | yi = fix(y); 223 | oup = y - yi; 224 | 225 | if (oup != 0.0) { 226 | if (yi != fix(yi * .5) * 2.) { 227 | swi = 1; 228 | } 229 | fact = -pi / sin(pi * oup); 230 | y += 1.; 231 | } else { 232 | return xinf; 233 | } 234 | } 235 | 236 | if (y < eps) { 237 | if (y >= xninf) { 238 | oup = 1.0/y; 239 | } else { 240 | return xinf; 241 | } 242 | 243 | } else if (y < 12.) { 244 | yi = y; 245 | if ( y < 1.) { 246 | z = y; 247 | y += 1.; 248 | } else { 249 | n = ( int ) y - 1; 250 | y -= ( double ) n; 251 | z = y - 1.0; 252 | } 253 | nsum = 0.; 254 | dsum = 1.; 255 | for (i = 0; i < 8; ++i) { 256 | nsum = (nsum + num[i]) * z; 257 | dsum = dsum * z + den[i]; 258 | } 259 | oup = nsum / dsum + 1.; 260 | 261 | if (yi < y) { 262 | 263 | oup /= yi; 264 | } else if (yi > y) { 265 | 266 | for (i = 0; i < n; ++i) { 267 | oup *= y; 268 | y += 1.; 269 | } 270 | 271 | } 272 | 273 | } else { 274 | if (y <= xmax) { 275 | y2 = y * y; 276 | sum = c[6]; 277 | for (i = 0; i < 6; ++i) { 278 | sum = sum / y2 + c[i]; 279 | } 280 | sum = sum / y - y + spi; 281 | sum += (y - .5) * log(y); 282 | oup = exp(sum); 283 | } else { 284 | return(xinf); 285 | } 286 | } 287 | 288 | if (swi) { 289 | oup = -oup; 290 | } 291 | if (fact != 1.) { 292 | oup = fact / oup; 293 | } 294 | 295 | return oup; 296 | } 297 | -------------------------------------------------------------------------------- /src/seq2sig/main.cpp: -------------------------------------------------------------------------------- 1 | #include "opts.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include "util/exception.h" 11 | #include "kmer/kmer_index.h" 12 | 13 | //---------- genome to signal (DNA) -------------// 14 | bool Genomes2SignalSequence(const std::vector& genomes, 15 | std::vector& index, std::vector& signals, 16 | std::vector& kmer_rec, int scale, 17 | int FIVE_or_SIX, int ZSCO_or_NOT, int WANT_TAIL) 18 | { 19 | /* 20 | //------- simple version -----------// 21 | { 22 | long bound=genomes.size(); 23 | index.assign(bound,0); 24 | signals.assign(bound,0); 25 | for(long i=0;i 5mer model 41 | { 42 | g::Mer2Signal::Genome2Index_5mer(genomes, index); 43 | bound = genomes.size()-4;//genomes.size()%5; 44 | signals.assign(bound*scale,0); 45 | kmer_rec.resize(bound*scale); 46 | long cur=0; 47 | for(long i = 0; i < bound; i++){ 48 | //-> get kmer 49 | std::string kmer(genomes.begin()+i,genomes.begin()+i+5); 50 | //-> get signal 51 | double sigval; 52 | if(index[i]<0)sigval=0; 53 | else{ 54 | sigval = g::Mer2Signal::AvgSignalAt_5mer(index[i]); 55 | if(ZSCO_or_NOT==1) //-> transfer to Zsco 56 | { 57 | sigval = (sigval-90.208351)/12.832660; 58 | } 59 | else //-> use original int value 60 | { 61 | sigval = (int)(5.7*sigval+14); 62 | } 63 | } 64 | //-> assign 65 | for(int c = scale; c--;){ 66 | signals[cur]=sigval; 67 | kmer_rec[cur]=kmer; 68 | cur++; 69 | } 70 | } 71 | } 72 | else //-> 6mer model 73 | { 74 | g::Mer2Signal::Genome2Index_6mer(genomes, index); 75 | bound = genomes.size()-5;//genomes.size()%5; 76 | signals.assign(bound*scale,0); 77 | kmer_rec.resize(bound*scale); 78 | long cur=0; 79 | for(long i = 0; i < bound; i++){ 80 | //-> get kmer 81 | std::string kmer(genomes.begin()+i,genomes.begin()+i+6); 82 | //-> get signal 83 | double sigval; 84 | if(index[i]<0)sigval=0; 85 | else{ 86 | sigval = g::Mer2Signal::AvgSignalAt_6mer(index[i]); 87 | if(ZSCO_or_NOT==1) //-> transfer to Zsco 88 | { 89 | sigval = (sigval-90.208199)/12.868652; 90 | } 91 | else //-> use original int value 92 | { 93 | sigval = (int)(5.7*sigval+14); 94 | } 95 | } 96 | //-> assign 97 | for(int c = scale; c--;){ 98 | signals[cur]=sigval; 99 | kmer_rec[cur]=kmer; 100 | cur++; 101 | } 102 | } 103 | } 104 | 105 | 106 | //---- tail k_mer ------// 107 | if(WANT_TAIL==1) 108 | { 109 | for(long i = bound; i < genomes.size(); i++){ 110 | for(int c = scale; c--;){ 111 | if(ZSCO_or_NOT==1) //-> transfer to Zsco 112 | { 113 | signals.push_back(0); 114 | } 115 | else 116 | { 117 | signals.push_back(5.7*100+14); 118 | } 119 | } 120 | } 121 | } 122 | 123 | } 124 | 125 | //---------- genome to signal (RNA) -------------// 126 | bool Genomes2SignalSequence_RNA(const std::vector& genomes, 127 | std::vector& index, std::vector& signals, 128 | std::vector& kmer_rec, int scale, 129 | int mv200_or_mv180, int ZSCO_or_NOT, int WANT_TAIL) 130 | { 131 | /* 132 | //------- simple version -----------// 133 | { 134 | long bound=genomes.size(); 135 | index.assign(bound,0); 136 | signals.assign(bound,0); 137 | for(long i=0;i for RNA only 144 | if(c=='C')val=-1; 145 | if(c=='G')val=-2; 146 | signals[i]=val; 147 | } 148 | return true; 149 | } 150 | */ 151 | 152 | long bound; 153 | if(mv200_or_mv180==1) //-> 200mv model 154 | { 155 | g::Mer2Signal::Genome2Index_5mer(genomes, index); 156 | bound = genomes.size()-4;//genomes.size()%5; 157 | signals.assign(bound*scale,0); 158 | kmer_rec.resize(bound*scale); 159 | long cur=0; 160 | for(long i = 0; i < bound; i++){ 161 | //-> get kmer 162 | std::string kmer(genomes.begin()+i,genomes.begin()+i+5); 163 | //-> get signal 164 | double sigval; 165 | if(index[i]<0)sigval=0; 166 | else{ 167 | sigval = g::Mer2Signal::RnaSignalAt_5mer_200mv(index[i]); 168 | if(ZSCO_or_NOT==1) //-> transfer to Zsco 169 | { 170 | sigval = (sigval-87.240242)/14.171575; 171 | } 172 | else //-> use original int value 173 | { 174 | sigval = (int)(5.7*sigval+14); 175 | } 176 | } 177 | //-> assign 178 | for(int c = scale; c--;){ 179 | signals[cur]=sigval; 180 | kmer_rec[cur]=kmer; 181 | cur++; 182 | } 183 | } 184 | } 185 | else //-> 180mv model 186 | { 187 | g::Mer2Signal::Genome2Index_5mer(genomes, index); 188 | bound = genomes.size()-4;//genomes.size()%5; 189 | signals.assign(bound*scale,0); 190 | long cur=0; 191 | for(long i = 0; i < bound; i++){ 192 | //-> get kmer 193 | std::string kmer(genomes.begin()+i,genomes.begin()+i+5); 194 | //-> get signal 195 | double sigval; 196 | if(index[i]<0)sigval=0; 197 | else{ 198 | sigval = g::Mer2Signal::RnaSignalAt_5mer_180mv(index[i]); 199 | if(ZSCO_or_NOT==1) //-> transfer to Zsco 200 | { 201 | sigval = (sigval-94.524117)/15.939267; 202 | } 203 | else //-> use original int value 204 | { 205 | sigval = (int)(5.7*sigval+14); 206 | } 207 | } 208 | //-> assign 209 | for(int c = scale; c--;){ 210 | signals[cur]=sigval; 211 | kmer_rec[cur]=kmer; 212 | cur++; 213 | } 214 | } 215 | } 216 | 217 | 218 | //---- tail k_mer ------// 219 | if(WANT_TAIL==1) 220 | { 221 | for(long i = bound; i < genomes.size(); i++){ 222 | for(int c = scale; c--;){ 223 | if(ZSCO_or_NOT==1) //-> transfer to Zsco 224 | { 225 | signals.push_back(0); 226 | } 227 | else 228 | { 229 | signals.push_back(5.7*100+14); 230 | } 231 | } 232 | } 233 | } 234 | 235 | } 236 | 237 | 238 | //---------------------- main ---------------------// 239 | int main(int argc, char **argv) 240 | { 241 | std::string input=""; 242 | std::string output=""; 243 | 244 | struct options opts; 245 | opts.scale=1; 246 | opts.kmer=1; 247 | opts.zsco=0; 248 | opts.rna=0; 249 | opts.name=0; 250 | if(GetOpts(argc, argv, &opts) < 0){ 251 | EX_TRACE("**WRONG INPUT!**\n"); 252 | return -1; 253 | } 254 | 255 | input=opts.input; 256 | output=opts.output; 257 | if(input=="" || output=="") 258 | { 259 | fprintf(stderr,"input or output is NULL \n"); 260 | return -1; 261 | } 262 | 263 | std::vector genomes; 264 | std::vector index; 265 | std::vector signals; 266 | g::io::ReadATCG(opts.input, genomes); 267 | 268 | //printf("read done \n"); 269 | 270 | std::vector kmer_rec; 271 | if(opts.rna==0) //-> DNA pore model 272 | { 273 | Genomes2SignalSequence(genomes, index, signals, kmer_rec, 274 | opts.scale, opts.kmer,opts.zsco,0); 275 | } 276 | else //-> RNA pore model 277 | { 278 | Genomes2SignalSequence_RNA(genomes, index, signals, kmer_rec, 279 | opts.scale, opts.rna,opts.zsco,0); 280 | } 281 | 282 | //printf("proc done \n"); 283 | 284 | if(opts.zsco==1) 285 | { 286 | if(opts.name==1) 287 | { 288 | g::io::WriteSignalSequence_withName(opts.output, signals, kmer_rec); 289 | } 290 | else 291 | { 292 | g::io::WriteSignalSequence(opts.output, signals); 293 | } 294 | } 295 | else 296 | { 297 | std::vector signals_ (signals.begin(), signals.end()); 298 | if(opts.name==1) 299 | { 300 | g::io::WriteSignalSequence_int_withName(opts.output, signals_, kmer_rec); 301 | } 302 | else 303 | { 304 | g::io::WriteSignalSequence_int(opts.output, signals_); 305 | } 306 | } 307 | 308 | //printf("write done \n"); 309 | 310 | return 0; 311 | } 312 | 313 | -------------------------------------------------------------------------------- /src/main/main.cpp: -------------------------------------------------------------------------------- 1 | #include "opts.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "proc/cwdtw.h" 9 | #include "util/exception.h" 10 | #include 11 | #include 12 | #include 13 | 14 | using namespace std; 15 | 16 | 17 | //-------- utility ------// 18 | void getBaseName(string &in,string &out,char slash,char dot) 19 | { 20 | int i,j; 21 | int len=(int)in.length(); 22 | for(i=len-1;i>=0;i--) 23 | { 24 | if(in[i]==slash)break; 25 | } 26 | i++; 27 | for(j=len-1;j>=0;j--) 28 | { 29 | if(in[j]==dot)break; 30 | } 31 | if(j==-1)j=len; 32 | out=in.substr(i,j-i); 33 | } 34 | void getRootName(string &in,string &out,char slash) 35 | { 36 | int i; 37 | int len=(int)in.length(); 38 | for(i=len-1;i>=0;i--) 39 | { 40 | if(in[i]==slash)break; 41 | } 42 | if(i<=0)out="."; 43 | else out=in.substr(0,i); 44 | } 45 | //---------------------- utility ------//over 46 | 47 | 48 | 49 | //----------- write alignment to file -------------//__2017.10.15__//(Sheng modified) 50 | void WriteSequenceAlignment(const char* output, 51 | const std::vector& reference_orig, const std::vector& peer_orig, 52 | const std::vector& reference, const std::vector& peer, 53 | vector >& alignment, int swap) 54 | { 55 | vector tmp_rec; 56 | double diff; 57 | for(long i = 0; i < alignment.size(); i++) 58 | { 59 | //----- output to string ----// 60 | std::ostringstream o; 61 | diff = std::fabs(reference[alignment[i].first]-peer[alignment[i].second]); 62 | if(swap==1) 63 | { 64 | o< [0] no verbose; 1 verbose 93 | opts.test = 0; //-> [0] not use test mode; 1 equal_ave, 2 peak_ave, 3 Fast_DTW 94 | opts.mode = 0; //-> [0] block bound; 1 diagonol bound 95 | 96 | 97 | //----- parse arguments -----// 98 | if(GetOpts(argc, argv, &opts) < 0){ 99 | EX_TRACE("**WRONG INPUT!**\n"); 100 | return -1; 101 | } 102 | 103 | std::string input1=opts.input; 104 | std::string input2=opts.peer; 105 | std::string output=opts.output; 106 | if(input1=="" || input2=="") 107 | { 108 | fprintf(stderr,"input1 or input2 is NULL \n"); 109 | return -1; 110 | } 111 | 112 | 113 | //======================= START Procedure ===================================// 114 | 115 | //=========================================// 116 | //----- 1. read genome translated signal -----// 117 | std::vector reference; 118 | if(!g::io::ReadSignalSequence(opts.input,reference)){ 119 | EX_TRACE("Cannot open %s.\n", opts.input); 120 | return -1; 121 | } 122 | std::vector reference_orig=reference; 123 | std::string genom_name_orig=opts.input; 124 | std::string genom_name; 125 | getBaseName(genom_name_orig,genom_name,'/','.'); 126 | 127 | //========================================// 128 | //----- 2. read nanopore raw signal -----// 129 | std::vector peer; 130 | if(!g::io::ReadSignalSequence(opts.peer,peer)){ 131 | EX_TRACE("Cannot open %s.\n", opts.peer); 132 | return -1; 133 | } 134 | std::vector peer_orig=peer; 135 | std::string signal_name_orig=opts.peer; 136 | std::string signal_name; 137 | getBaseName(signal_name_orig,signal_name,'/','.'); 138 | 139 | 140 | //----- length check ------// 141 | int swap=0; 142 | if(reference.size()>peer.size()) 143 | { 144 | std::vector tmp=peer; 145 | peer=reference; 146 | reference=tmp; 147 | swap=1; 148 | } 149 | 150 | //==================================================// 151 | //------3. process initial input signals ----------// 152 | 153 | //----- 3.1 Zscore normaliza on both signals -----// 154 | g::proc::ZScoreNormalize(reference); 155 | g::proc::ZScoreNormalize(peer); 156 | 157 | //----- 3.2 calculate length ratio between input signals -----// 158 | double alpha = (double)peer.size()/reference.size(); 159 | 160 | 161 | //--------------- Just For Test (Fast_DTW) -------------------// 162 | if(opts.test==3) 163 | { 164 | //------ 5.1 generate initial alignment via FastDTW ------// 165 | vector > cosali; 166 | double tdiff; 167 | long max_level=100000; //here we fix maximal level 168 | g::cwdtw::FastDTW(reference, peer, cosali, opts.radius, max_level,opts.mode, &tdiff); 169 | vector > bound; 170 | g::cwdtw::BoundGeneration(cosali, opts.radius, bound, opts.mode); 171 | //------ 5.2 generate final alignment via cDTW ------// 172 | std::vector > alignment; 173 | tdiff = g::proc::BoundDynamicTimeWarping(reference, peer, bound, alignment); 174 | fprintf(stderr,"%s %s %lf %d %lf\n",signal_name.c_str(),genom_name.c_str(),tdiff,alignment.size(),tdiff/alignment.size()); 175 | 176 | //=================================================// 177 | //------ 6. output final alignment to file -------// 178 | if(output!="") 179 | WriteSequenceAlignment(opts.output, reference_orig, peer_orig, reference, peer, alignment, swap); 180 | 181 | //----- exit -----// 182 | return 0; 183 | } 184 | 185 | 186 | //====================================================// 187 | //----- 4. continous wavelet transform --------------// 188 | std::vector > rcwt, pcwt; 189 | 190 | if(opts.verbose ==1){ 191 | EX_TRACE("CWT Analysis...\n"); 192 | } 193 | 194 | long npyr = opts.level; // default: 3 195 | double scale0 = opts.scale0; // default: sqrt(2) 196 | double dscale = 1; // default: 1 197 | 198 | g::cwdtw::CWTAnalysis(reference, rcwt, scale0, dscale, npyr); 199 | g::cwdtw::CWTAnalysis(peer, pcwt, scale0*alpha, dscale, npyr); 200 | 201 | //------ 4.1 Zscore normaliza on both CWT signals -----// 202 | //if multiscale is used, pyr logical should be added. 203 | for(long i = 0; i < npyr; i++){ 204 | g::proc::ZScoreNormalize(rcwt[i]); 205 | g::proc::ZScoreNormalize(pcwt[i]); 206 | } 207 | 208 | 209 | //============================================// 210 | //------ 5. multi-level WaveletDTW ----------// 211 | std::vector > cosali; 212 | double tdiff; 213 | 214 | if(opts.verbose ==1){ 215 | EX_TRACE("Coarse Alignment...\n"); 216 | } 217 | g::cwdtw::MultiLevel_WaveletDTW(reference, peer, rcwt, pcwt, cosali, opts.radius, opts.test, opts.mode, &tdiff); 218 | if(opts.verbose ==1){ 219 | EX_TRACE("Average Deviation (%.1lf/%ld=%.3lf)\n", tdiff, cosali.size(), tdiff/cosali.size()); 220 | } 221 | 222 | //------ 5.1 generate final boundary -------// 223 | std::vector > bound; 224 | g::cwdtw::BoundGeneration(cosali, opts.radius, bound, opts.mode); 225 | 226 | //------ 5.2 generate final alignment via cDTW ------// 227 | std::vector > alignment; 228 | tdiff = g::proc::BoundDynamicTimeWarping(reference, peer, bound, alignment); 229 | fprintf(stderr,"%s %s %lf %d %lf\n",signal_name.c_str(),genom_name.c_str(),tdiff,alignment.size(),tdiff/alignment.size()); 230 | 231 | 232 | //=================================================// 233 | //------ 6. output final alignment to file -------// 234 | if(output!="") 235 | WriteSequenceAlignment(opts.output, reference_orig, peer_orig, reference, peer, alignment, swap); 236 | 237 | //----- exit -----// 238 | return 0; 239 | } 240 | 241 | -------------------------------------------------------------------------------- /src/util/qsort.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2008 Noah Snavely (snavely (at) cs.washington.edu) 3 | * and the University of Washington 4 | * 5 | * This program is free software; you can redistribute it and/or modify 6 | * it under the terms of the GNU General Public License as published by 7 | * the Free Software Foundation; either version 2 of the License, or 8 | * (at your option) any later version. 9 | * 10 | * This program is distributed in the hope that it will be useful, 11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 | * GNU General Public License for more details. 14 | * 15 | */ 16 | 17 | /* qsort.c */ 18 | /* Contains a routine for sorting a list of floating point numbers and 19 | * returning the permutation that would map the original list to the 20 | * sorted list */ 21 | 22 | #include 23 | #include 24 | #include 25 | #include 26 | 27 | #include "qsort.h" 28 | 29 | typedef enum { 30 | QSORT_ASCENDING, 31 | QSORT_DESCENDING 32 | } qsort_order_t; 33 | 34 | static qsort_order_t qsort_order = QSORT_DESCENDING; 35 | 36 | /* Set whether we should sort in ascending or descending order */ 37 | void qsort_ascending() 38 | { 39 | qsort_order = QSORT_ASCENDING; 40 | } 41 | 42 | void qsort_descending() 43 | { 44 | qsort_order = QSORT_DESCENDING; 45 | } 46 | 47 | void qsort_perm_r(int n, double *arr, int *perm); 48 | 49 | /* Sorts the array of doubles `arr' (of length n) and puts the 50 | * corresponding permutation in `perm' */ 51 | void qsort_perm(int n, double *arr, int *perm) { 52 | int i; 53 | 54 | /* Create the identity permutation */ 55 | for (i = 0; i < n; i++) 56 | perm[i] = i; 57 | 58 | qsort_perm_r(n, arr, perm); 59 | } 60 | 61 | #define SORT_ASCENDING 62 | /* #define SORT_DESCENDING */ 63 | 64 | void qsort_perm_r(int n, double *arr, int *perm) { 65 | int pivot_idx; 66 | double *r, *l; 67 | double pivot; 68 | double *split; 69 | 70 | if (n <= 1) 71 | return; 72 | 73 | /* Pick the pivot */ 74 | pivot_idx = n / 2; 75 | pivot = arr[pivot_idx]; 76 | l = arr; 77 | r = arr + (n - 1); 78 | 79 | while (l < r) { 80 | if (qsort_order == QSORT_ASCENDING) { 81 | if (*l >= pivot && *r <= pivot) { 82 | /* Swap */ 83 | int lidx = (int) (l - arr); 84 | int ridx = (int) (r - arr); 85 | double tmp = *l; 86 | int tmpidx = perm[lidx]; 87 | 88 | *l = *r; 89 | *r = tmp; 90 | 91 | perm[lidx] = perm[ridx]; 92 | perm[ridx] = tmpidx; 93 | 94 | l++; 95 | } else if (*l < pivot) { 96 | l++; 97 | } else if (*r > pivot) { 98 | r--; 99 | } else { 100 | printf("Execution should not reach this point\n"); 101 | return; 102 | } 103 | } else if (qsort_order == QSORT_DESCENDING) { 104 | if (*l <= pivot && *r >= pivot) { 105 | /* Swap */ 106 | int lidx = (int) (l - arr); 107 | int ridx = (int) (r - arr); 108 | double tmp = *l; 109 | int tmpidx = perm[lidx]; 110 | 111 | *l = *r; 112 | *r = tmp; 113 | 114 | perm[lidx] = perm[ridx]; 115 | perm[ridx] = tmpidx; 116 | 117 | l++; 118 | } else if (*l > pivot) { 119 | l++; 120 | } else if (*r < pivot) { 121 | r--; 122 | } else { 123 | printf("Execution should not reach this point\n"); 124 | return; 125 | } 126 | } else { 127 | printf("[qsort_perm_r] Unknown qsort order\n"); 128 | } 129 | } 130 | 131 | /* At this point l == r */ 132 | split = l; 133 | 134 | /* Sort the left subarray */ 135 | qsort_perm_r((int) (split - arr), arr, perm); 136 | 137 | /* Sort the right subarray */ 138 | qsort_perm_r(n - (int) (split - arr), split, perm + (split - arr)); 139 | } 140 | 141 | /* Find the median in a set of doubles */ 142 | double median(int n, double *arr) { 143 | return kth_element(n, n / 2, arr); 144 | } 145 | 146 | /* Find the median in a set of doubles (*/ 147 | double median_copy(int n, double *arr) { 148 | return kth_element_copy(n, n / 2, arr); 149 | } 150 | 151 | /* Find the kth element without changing the array */ 152 | double kth_element_copy(int n, int k, double *arr) { 153 | double *arr_copy = (double *)malloc(sizeof(double) * n); 154 | double kth_best; 155 | 156 | memcpy(arr_copy, arr, sizeof(double) * n); 157 | kth_best = kth_element(n, k, arr_copy); 158 | free(arr_copy); 159 | 160 | return kth_best; 161 | } 162 | 163 | static int partition(int n, double *arr) { 164 | int pivot_idx = n / 2; 165 | double pivot = arr[pivot_idx]; 166 | double tmp; 167 | int i, store_index; 168 | 169 | /* Swap pivot and end of array */ 170 | tmp = arr[n-1]; 171 | arr[n-1] = pivot; 172 | arr[pivot_idx] = tmp; 173 | 174 | store_index = 0; 175 | for (i = 0; i < n-1; i++) { 176 | if (arr[i] < pivot) { 177 | tmp = arr[store_index]; 178 | arr[store_index] = arr[i]; 179 | arr[i] = tmp; 180 | store_index++; 181 | } 182 | } 183 | 184 | tmp = arr[store_index]; 185 | arr[store_index] = arr[n-1]; 186 | arr[n-1] = tmp; 187 | 188 | return store_index; 189 | } 190 | /* Find the kth element in an unordered list of doubles */ 191 | double kth_element(int n, int k, double *arr) { 192 | if (k >= n) { 193 | printf("[kth_element] Error: k should be < n\n"); 194 | return 0.0; 195 | } else { 196 | int split = partition(n, arr); 197 | if (k == split) 198 | return arr[split]; 199 | else if (k < split) 200 | return kth_element(split, k, arr); 201 | else 202 | return kth_element(n - split - 1, k - split - 1, arr + split + 1); 203 | } 204 | } 205 | 206 | #if 0 207 | /* Find the kth element in an unordered list of doubles */ 208 | double kth_element(int n, int k, double *arr) { 209 | if (k >= n) { 210 | printf("[kth_element] Error: k should be < n\n"); 211 | return 0.0; 212 | } else { 213 | /* Pick a pivot */ 214 | int pivot_idx = n / 2; 215 | double pivot = arr[pivot_idx]; 216 | double *l = arr, *r = arr + n - 1, *split; 217 | int split_idx; 218 | 219 | while (l < r) { 220 | if (*l >= pivot && *r <= pivot) { 221 | /* Swap */ 222 | double tmp = *l; 223 | 224 | *l = *r; 225 | *r = tmp; 226 | 227 | l++; 228 | r--; 229 | } else if (*l < pivot) { 230 | l++; 231 | } else if (*r > pivot) { 232 | r--; 233 | } else { 234 | printf("Execution should not reach this point\n"); 235 | } 236 | } 237 | 238 | /* At this point l == r */ 239 | split = l; 240 | split_idx = (int)(l - arr); 241 | 242 | if (split_idx == k) { 243 | return arr[split_idx]; 244 | } else if (split_idx < k) { 245 | return kth_element(n - split_idx, k - split_idx, split); 246 | } else { 247 | return kth_element(split_idx, k, arr); 248 | } 249 | } 250 | } 251 | #endif 252 | 253 | /* Permute the array `arr' given permutation `perm' */ 254 | void permute_dbl(int n, double *arr, int *perm) { 255 | double *tmparr = new double[n]; 256 | int i; 257 | 258 | for (i = 0; i < n; i++) 259 | tmparr[i] = arr[perm[i]]; 260 | 261 | memcpy(arr, tmparr, sizeof(double) * n); 262 | 263 | delete [] tmparr; 264 | } 265 | 266 | void permute(int n, int size, void *arr, int *perm) { 267 | void *tmparr = malloc(size * n); 268 | int i; 269 | 270 | for (i = 0; i < n; i++) 271 | memcpy((char *) tmparr + i * size, (char *) arr + perm[i] * size, size); 272 | 273 | memcpy(arr, tmparr, size * n); 274 | 275 | free(tmparr); 276 | } 277 | 278 | /* Returns true if the given array is sorted */ 279 | int is_sorted(int n, double *arr) { 280 | int i; 281 | 282 | for (i = 0; i < n - 1; i++) { 283 | if (arr[i] > arr[i+1]) 284 | return 0; 285 | } 286 | 287 | return 1; 288 | } 289 | 290 | #if 0 291 | int main() { 292 | int n = 2048; 293 | double *arr = malloc(sizeof(double) * n); 294 | int *perm = malloc(sizeof(int) * n); 295 | double *arr2 = malloc(sizeof(double) * n); 296 | int i; 297 | 298 | for (i = 0; i < n; i++) 299 | arr[i] = ((double) rand()) / RAND_MAX; 300 | 301 | memcpy(arr2, arr, sizeof(double) * n); 302 | 303 | qsort_perm(n, arr, perm); 304 | 305 | printf("%s\n", is_sorted(n, arr) ? "List is sorted" : "List is not sorted"); 306 | permute(n, sizeof(double), arr2, perm); 307 | printf("%s\n", is_sorted(n, arr2) ? "List is sorted" : "List is not sorted"); 308 | 309 | free(arr); 310 | free(arr2); 311 | free(perm); 312 | 313 | return 0; 314 | } 315 | #endif 316 | -------------------------------------------------------------------------------- /example/0a0dc008-5d60-4f7f-aa24-c78da021f7bf.fasta: -------------------------------------------------------------------------------- 1 | >refer_sequence 2 | CGCCCTGGCAGAATTTTCTGCCGCCGTTGCCGAGGAAGCTGCACGACCGGCACTTGATGATGCGTTCGTTTCTGATGATTTTGCTGCCTCTTTTGAGGCCACCGCATCTCGTGCTGAAGTGGCGGCCTCTGACGCTTTCGTGGCCGCGGTGGAGGCAGACGTGGCGGCTGATTGTTGTGACGCTGCAGCATTCGTTTCTGACGTTTTCGCCGCACCGGCACTGGTGGCCGCCGCGTTTTTTGAGGACTCTGCGGCTGCGGCACTTTTTTCCGCTTCAGTGGCCTTTGCTGATGCCGCTTCTGCGCCGGAGGACGCTTCCTGAGCTGACGATGCAGCCTGTCCGGCGGACGTGCTGGCGGCGCGTGCTGAGTCAGTTGCATCAGTCACAAGGGCCGCGACCTGAGCAGCTGATGCACTGGCATCGCCGGCTGATTTCTTCGCGTCTGCCGTACTCTGTGCCACCACGGACGCGTTACGCGCCACCTCTTCCACCATCAGTTCAAGACGACGCAGCACCTCCGGCCGGGCATCATCCTCCGTCATGGCACAGAGAAAATCATTCAGCGTCCCCGGTTGTGAATCTTCATACACGGTGATGGTCCCGGCGTGCGATGGTGGAAAACCGTCAACCTGCAGGATGACACTGTACTGACCGTACTCCACATCCATGCTGTAACGCCCGGCTTCATCCGGATTCTCTGAGCCCACCGTGTTCACCACCACCGTGGTGCTGTTACGTCTGGCTTTCAGCTGAATGGTGCAGTTCTGTACCGGTTTTCCTGTGCCGTCTTTCAGGACTCCTGAAATCTTTACTGCCATATTCACCCCACAAAAAAGCCCACCGGTTCCGGCGGGCTGTCATAACACTGTGTTACCTGGCTAATCAGAATTTATAACCGACCCCAACGATGAATCCGTCAGTACGCCAGTCGCCACTGCCGGAGCCTTCATAAGCAATATCAACAACGACGGACGCTGCCGGATTAATCTGTATACCTGCACTCCACGCCACTGAGGTATGCCGCATTGCACTTTCGTCCCTGGCAGTGGTCGTCTCTTTCATATACCCGGGAGTGATTTCCGTCTTACGGTAATCCATTGTACTGCCGGACCACCGACTGTGAGCCACTCCGGCCATGGCGTACGCACTGACCTGCTTACTGATTTGTAAAACCGGTCCGGCCATCACGCTCACATAACGTCCACGCAGGCTCTCATAGTGAAACGTATCCTCCCCGGTCATCACTGTGCTGCTCTTTTTCGACGCGGCGAACCCCAGGGAAGCCATCACCCCCACACTGTCCGTCAGCTCATAACGGTACTTCACGTTAATCCCTTTCAGATGACTCACACCGGTATCCCCGCCCGACAACGACGGCAATGTACCCGGTTTCACTTGAAAATAGCCCACCGTAAACGTACCATGTCCACCTTCCGCACGGGCCGGAGTGACTGTCACCGCAAGTGCGGCAAAGACAGCAACGGCAATACACACATTACGCATCGTTCACCTCTCACTGTTTTATAATAAAACGCCCGTTCCCGGACGAACCTCTGTAACACACTCAGACCACGCTGATGCCCAGCGCCTGTTTCTTAATCACCATAACCTGCACATCGCTGGCAAACGTATACGGCGGAATATCTGCCGAATGCCGTGTGGACGTAAGCGTGAACGTCAGGATCACGTTTCCCCGACCCGCTGGCATGTCAACAATACGGGAGAACACCTGTACCGCCTCGTTCGCCGCGCCATCATAAATCACCGCACCGTTCATCAGTACTTTCAGATAACACATCGAATACGTTGTCCTGCCGCTGACAGTACGCTTACTTCCGCGAAACGTCAGCGGAAGCACCACTATCTGGCGATCAAAAGGATGGTCATCGGTCACGGTGACAGTACGGGTACCTGACGGCCAGTCCACACTGCTTTCACGCTGGCGCGGAAAAGCCGCGCTCGCCGCCTTTACAATGTCCCCGACGATTTTTTCCGCCCTCAGCGTACCGTTTATCGTACAGTTTTCAGCTATCGTCACATTACTGAGCGTCCCGGAGTTCGCATTCACACTGCCACTGATATCCGCATTTTTAGCGGTCAGCTTTCCGTCCGGTGTCAGGGAAAAGGCCGGAGGATTGCCGCCGCTGGTAATGGTGGGGGCCGTCAGGCGCTTCAGGAACACGTCGTTCATGAATATCTGGTTGCCCTGCGCCACAAACATCGGCGTTTCATTCCCGTTTGCCGGGTCAATAAATGCGATACGATTGGCGGCAACCAGAAACTGGCTCAGTTTGCCTTCCTCCGTGTCCTCCATGCTGAGGCCAATACCCGCGACATAATGTTTGCCGTCTTTGGTCTGCTCAATTTTGACAGCCCACATGGCATTCCACTTATCACTGGCATCCTTCCACTCTTTCGAAAACTCCTCCAGTCTGCTGGCGTTATCCTCCGTCAGCTCGACTTTTTCCAGCAGCTCCTTGCCGAGATGGGATTCGGTTATCTTGCCTTTGAAAAAATCCAGGTAACCTTCCGCATCATCGCTCGCCCGACCGACGGCCTCCACGAATGCCGATTTGCCAACGGTGTTCACACTGCGGATATAAAAGTAATAATCATGGCCCGGTTTGATATTGATACTGGCGGCTATCCAGTACAGCGCCGTACCAAGATAACGCGTGCTGGTTTCAACCTGTCTGATATCCGCAATCTGCTTTTCCGAGAACCAGAACTCAAACTGTACCGTCGGGTCATAAACGGCAAGATGCGGCGTGGCGGTTATCTGAAAATAGCCCGGCGTCAGCTCAATCCTCGACGGTGCTGCCGGTGCGGCAATCCGGAACGATACCGACGCCGGATCGCCCTGCTGCCCCCACGCATTTACCGCCCGGACTGTCAGCCTGTAGTTCCCCAGCGCCAGTTGCGTGAAGCGGTATGTGGTTTCCGTCGTCCGGGCCGTGCTGACCAGCCGCTCACTGCCGTCGTCCGCTGTTACGGTCAGACGGAGCAGGAAACTCACGCCCTTCACCACCTTCGGTGTGTCCCATCGCGCCAGCACCTGATATTCCCCGCTGTCTGCAGTGACTTCTGCGGTCAGGTGCTGCACCGCTGGCGGCGTGACACCATTCACCGTGCCACTCTGTTCGCCGTCAAAGTGCGCCCCGTTATCCACGATGGCCTCTTTTTCCGGCACATGCTGCACGGCGGTGATGGCATACGTGCCGTCGTCGTTCTCACGGATACTCACGCAGCGGAACAGTCGCTGGCGCAGCGTCGGCAGCTTCAGCTCCCATACGCTGTATTCAGCAACACCGTCAGGAACACGGCTCACTTTTACCTTCACGCCGTCGGTGACGGACTGAACCTCCACGCTGACCGGATTGCCACTTCCGTCAACCAGGCTTATCAGCGCGGTACCGGAGGATGGCAGCGTGATTTCACGGTCGAGCGTCAGCGTCCGGGTCTGGCTGTTCACCGCCAGCACACGACCACCGGTGCTGATACCGGCATAGTCATCATCGCAGATTTCAATAACATCGCCCGGTACATGGCGAAGCCCTTCTGCGCCGACGCTGAAATCCACGGTCTGCGTTTCCAGCAGTTCTGTTTTAATCAGCCACAGCCCGGCGCGGTGTGCCTGCCCCCGGCTGGTACAGCCAAAGGCATCCATCTTCGTAACATTACGACCGTAACGGGCAATGGCCTGCGTATCTTCAACAAGCTCTGTCGCCGTCTCCCAGCCGTTGTTCGGGTCAATCCAGTTCACCTCAACGGCATTATGGCGGTCCTTCAGGGCGCTGAAGCTGTAGCGGAACGGCGCGCCATCATCCGGCATCACCACATTACTGCGGTTATAGGTCCACGTCTTATCCGACGGTCGGTCCTGCACGAACGTCAGCGTCTGCCCGTTCCATACCGGCATACAGCGCATCGCCGAGCAGAAATCGCTGAGCACATCCCACGCCTTACGCTGTGTGGTCAGGTACGCATTACAGGTGATGCGCGGCTCCGTGCCGCCAAAGCCGTCCGGCACTGACTGGTCGCAGTACTGGCCGATGACATACAGCGCCCATTTATCCACATCCGCCGCACCAAGACGTTTCCCCATGCCGTAGCGCGGATGGGTCAGCATATCCCACAGACACCAGGCCATGTTGTTGCTGTATGCCGGTTTAAACGTTCCGTCCCAGATACCGCTGTATTGCCGCGTCTGCGGGTTATAGTTCGACGGCACCTGCAGAATACGCCCGCGCAGATGATAATTACGGCTCACCTGCTGGCTGCCGAACTGCTCCGAGTCCACCTGCACGCCGACCAGTGCCGTGTTCGGGTAGCACTGTTTCACATCGATGATTTCAGTGTATGACGACCAGAGCGTTTTGTTCTGCAGCTGGTCTGTGGTGCTGTCCGGCGTCATCCTGCGCATCCGGATATTAAACGGGCGCGGCGGCAGGTTACCCATCACCACCGAGGCCAGATACTGCGAGGTGGTTTTGCCCTTAATGGTGATGTCTTTTTCCGTCACCCAGCCACCGTTACGTTGTATCTGAACCAGCAGGCGGACTTCCGACGGATTCCTGTCACCCTTTGAGGTGGTTTCCACCAGTGCCTGTACACCGAAGGTAAAGCGCAGACGGTCGATGTTTGCAGACGTAATGGTGCGGGTGATCGGCGTGTCATATTTCACTTCCGTACCCAGCACCGTCTCGGAGCCGGAGGATTCAAATCCCTCCGGCGGAGTCTGCTCCTGCTCACCAGCCCGGAACACCACCGTGACACCGGATATGTTGGTATTCCCCTCAGTGTCCAGCACCGGCGTACTGTTCAGCAGCACGCTTTTTAAGCCATCCACCGGACCTTCAATCGGCCCTTCGCTGATGGCATCGATCACACTCAGCAACTGCGTGGACTTCAGGTTGTCCTTCGCTTCGCGCGGGGTATGCCCCTTACTGCTTCCTTTACCCATTCCTCACGCTCCATAAATGACAAAACCGCCCGCAGGCGGTTTCACATAAAACATTTTGCATCAGCGACCAATCACCACAACCTGACCACCGTCCCCTTCGTCTGCCGTGCTGATCTCCTGAGAAACCACGCGTGACCCCACGCGCATTTCCCCGTACAGAACAGGCAGAACATTGCCCTGGGCAACCATGTTATCCAGTGAGGAGAAATAGGTGTTCTGCTTACCGTTATCCGTTGTCTGTATACGGGGAGTTCTGGCTTTCGGTGCCAGCATCTGCGCCACACCACCGAGCACCATACTGGCACCGAGAGAAAACAGGATGCCGGTCATACCACCGGCCCCAATGGCTGCCCCCCATGCTGCAAGGGTGGCTCCGGCGGTAAAGAATGATCCGGCAATGGCGGCAGCCCCCAGGACAATCTGGAATACGCCACCTGACTTGGCCCCGGCGACTCTGGGAACAATATGAATTACAGCGCCATCAGGCAGAGTCTCATGTAACTGCGCCGTTAACCCGGACGTGCTGACGTCCCGCCCGGCAATCCGTACCTGATACCAGCCGTCGCTCAGTTTCTGACGAAACGCCGGGAGCTGTGTGGCCAGTGCCCGGATGGCTTCAGCCCCCGTTTTCACACGAAGGTCGATGCGGCGACCAAATCGTTGTAAATCCCCGTAAAGGCAGATGCGCGCCATGCCCGGTGACGCCAGAGGGAGTGTGTGCGTCGCTGCCATTTGTCGGTGTACCTCTCTCGTTTGCTCAGTTGTTCAGGAATATGGTGCAGCAGCTCGCCGTCGCCGCAGTAAATTGCGGCGTGATTCGGCACTGATGAACCAAAACAGCACAGCAGCACATCGCCCGGCTGTGCCGCTGACAACGGCACCTGATACAGCCCCGTCGCCTCCAGATTATCCAGATAGAGATTCTGGCCGTTACGCCACCAGTCATCCTCACGATGAAAGTCCGGCATCTCAATCCCCGCCAGATGATAAGCATCCCGGAACAGTGTGTAACAGTCCGTCACACCGTGCTCAAAGCGCCGCCCGGTGAGATGCGGCACACAGCGGAACTTATGAATCGTCCCCCGGCAGACCAGCCACCACGGCAAATCACTCTGCACCTGCAGCCGCCGGTCGGCCTCACTCAGCCAGGGCAGACCACCGGGGTGGCTGTGGACCAGCGCCACAATCTCACCCTGCATTTCTGCCTGCAGCCAGTCTTCCGGCGACATACGGAAATAGCCTCCGGCTCACCGGAGATATTCACGCAGGGGAAATATCTTTCCCCCTCCGGCGTGCTTACCACGAAGCCGCACGACTCCGCTGGCGCACATCGCCGGGCGTGCGCCAGAATCGCTGATTCTGTCTGTGTCATGGGATTTACTGCGAAAGTTTGTTAATGGAAAGGAAGCCGCCAAAGTTGCCGACGTTATTGCGGAACTTACAACCGCTCAGGCATTTGCTGCATTTATCCTTCGTGATATCGGACGTTGGCTGGTCATATTCATCCGCGACAGCCGGACCGCTATAACCGCACTCGTCACCGCGATAGGTCCAGGTGCAGGTGTTGGCCAGCATGATACGTCCCGGAAAAACAGCGCCATCCGTTTCCGTCGGCGTGGACAGTACAAAGGAGGCACTCACCGCGCTCAGTTCGCTGCACTGCTCAATGCGCCAGCGGCTGATCACCTCCTGCTCCGGATCGGCGTAACTGTTTCCGTTGACGAAGTTCACCGCATCCAGAAAACGGGCGTAAACCTTACGCCGGACCACCGTTCCGCCGACCAGACTCTGCATATCTTCCGCCATCCCGGTGACCATACCGTACAGGTTAGAAACCGTCAGCGTGGGGCGCGTACTGGTGCCTTTGCCATTCAGTTCAAAACCGCTCCCCTGAATGGGATACGGCTGATACTGTCGCCCCTGCCAGGTGACCGGCTCACCTTTTTCGTTCTGCTCATTACAGAAAAAATAACGTTCTCCACCGACCTCTGTCAGGTCGATTTCCCAGAGCACCACGCTGGCCGACTGCTCCGCACGGGTGCATTCATTCAGTGTTTCCTGCCGGATATCCTGCATCAGTTCACCACCTGTTCAAACTCTGCGCTGAACTCAACACGCAGCATACTGACCCGCGACGACCATTTTGCGCAGGTCACCTTTATCTGCCGCCACTCATAAGGCGGCGTCCACAGAAAGGATTTCCAGCCCCCGTGCTCTTCCAGAAACGACTCCAGTACCGTGGCCTCCTCACGGGGGACAGAAAGCGTCACGCTGTACGTTTTCAGGTTGGCATTCAGCCCGGCAGGCGCTCGCTGAGAATAGCCATCACCAAAGCGCACCTTTCTTACAGAAGGGACCGAAGCCACATCCATACCGGGTTTCACTTTCCAGCGGAAGGTCTTCATCGTCCACCTCCGGAGAACAGGCCACCATCACGCATCTGTGTCTGAATTTCATCACGGGCACCCTTGCGGGCCATGTCATACACCGCCTTCAGAGCAGCCGGACCTATCTGCCCGTTCGTGCCGTCGTTGTTAATCACCACATGGTTATTCTGCTCAAACGTCCCGGACGCCTGCGACCGGCTGTCTGCCATGCTGCCCGGTGTACCGACATAACCGCCGGTGGCATAGCCGCGCATCAGCCGGTAAAGATTCCCCACGCCAATCCGGCTGGTTGCCTCCTTCGTGAAGACAAACTCACCACGGTGAACAATCCCCGCTGGCTCATATTTGCCGCCGGTTCCCGTAAATCCTCCGGTTGCAAAATGGAATTTCGCCGCAGCGGCCTGAATGGCTGTACCGCCTGACGCGGATGCGCCGCCACCAACAGCCCCGCCAATGGCGCTGCCGATACTCCCGACAATCCCCACCATTGCCTGCTTAAGCAGAATTTCTGTCATCATGGACAGCACGGAACGGGTGAAGCTGCGCCAGTTCTGCTCACTGCCGGTCAGCATCGCCGCCATATTCTGTGCAATACCATCAAAGGTCTGCGTGGCTGCACTTTTTACCTGCGACATACTGTCCGTGGCGCTCTCTTCCCACTCACTCCAGCCGGACTTCAGGCCTGCCATCCAGTTCCCGCGAAGCTGGTCTTCAGCCGCCCAGGTCTTTTTCTGCTCTGACATGACGTTATTCAGCGCCAGCGGATTATCGCCATACTGTTCCTTCAGGCGCTGTTCCGTGGCTTCCCGTTCTGCCTGCCGGTCAGTCAGCCCCCGGCTTTTCGCATCAATGGCGGCCCGTTTTGCCCGTTGCTGCTGTGCGAATTTATCCGCCTGCTGCGCCAGCGCGTTCAGGCGCTCCTGATACGTAACCTTGTCGCCAAGTGCAGCCAGCTGGCGTTTGTACTCCAGCGTCTCATCTTTATGCGCCAGCAGGGATTTCTCCTGTGCAGACAGCTGGCGACGTTGCGCCGCCTCCTCCAGTACCGCGAACTGACTCTCCGCCTTCCACAAATCCCGGCGCTGCTGGCTGATTTTCTCATTTGCTCCGGCATGCTTCTCCAGCGTCCGGAGTTCTGCCTGAAGCGTCAGCAGGGCAGCATGAGCACTGTCTTCCTGACGATCGCCCGCAGACACCTTCACGCTGGACTGTTTCGGCTTTTTCAGCGTCGCTTCATAATCCTTTTTCGCCGCCGCCATCAGCGTGTTGTAATCCGCCTGCAGGATTTTCCCGTCTTTCAGTGCCTTGTTCAGTTCTTCCTGACGGGCGGTATATTTCTCCAGCGGCGTCTGCAGCCGTTCGTAAGCCTTCTGCGCCTCTTCGGTATATTTCAGCCGTGACGCTTCGGTATCGCTCTGCTGCTGCGCATTTTTGTCCTGTTGAGTCTGCTGCTCAGCCTTCTTTCGGGCGGCTTCAAGCGCAAGACGGGCCTTTTCACGATCATCCCAGTAACGCGCCCGCGCTTCATCGTTAACAAAATAATCATCCTTGCGCAGATTCCAGATGTCGTCTGCTTTCTTATACGCAGCCTCTGCCTTAATCAGCATCTCCTGCGCGGTATCAGGACGACCAATATCCAGCACCGCATCCCACATGGATTTGAATGCCCGCGCAGTCCTGTCTGCCCAGGTCTCCAGCGTGCCCATGTTCTCTTTCAGGCGGCGGGTCTGGTCATCAAACCCTTTCGTTGCGGCCTCGTTCGCCGCCTGCAATGCCCCGGCTTCATCGCCGGAACGCTGCAACTGAGCAACATACGCAATCTGCTCCGCCGACACGTTATGGAACTGGCGAGCCATCGCCGTCAGCCCCGACGTCGGGTCTGTGGTCAGCTTCCCGAAGGCTTCAGCGACCTTGTCCACCTCCACGCCGGATGCAGAGGAGAAACGCGCCACACTCTGGCTGATGGACGCAATCTGAGCCTCACCGCTTACCCCCGCCTTAACCAGTGCGCTGAGTGACTCGCTGGTCTGGTTAAACGTCAGCCCTGCCGCCTGCCCGGCTCTGGACAGGACCAGCATACGATCTGCCGTCAGTCCCGCCTGATTGCCGGAAAGGACCAGCGTTTTGTTGAAATCGGACAGGGTTGAGTTGCCCTGATACCAGGCATACGCCAGCGCACCGGTCGCCACCGCCAGCGAGGTGGCCCCCACCATCGGCAGGGTGATCGCACCGGCAAGCCCCCTGAACATGGGGATCATCCCGCCGAAGGAGTCCTTCACCTGCCCCCCCTGTTGCAGCAGGATCAGCCACGGACTTTGCCCGCCTGCAAGCTGCGTGGCCACGTCGGTGAACTGTGCAGGCAGCATACGCATGGCGGCTTTATACTGCCCGACGGAAATCCCCGCTTTCTGTGCAGCCAGCGCCTGTCGGCTCAGCGACTGTTCAACGACTGCCGCTGTTTTTTTCGCATCACTTTCCGTACCAGAAAAATGACGCCTGACTCTGGCCATCTGCTCGTCAAATCTGGCCGCATCCAGACTCAAATCAACGACCAGATCGCCTACCGGTTCAGCC 3 | -------------------------------------------------------------------------------- /lib/wavelib/src/cwt.c: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (c) 2015, Rafat Hussain 3 | */ 4 | /* 5 | This code is a C translation ( with some modifications) of Wavelet Software provided by 6 | C. Torrence and G. Compo, and is available at URL: http://atoc.colorado.edu/research/wavelets/''. 7 | */ 8 | 9 | #include "cwt.h" 10 | 11 | static int factorial2(int N) { 12 | int factorial,i; 13 | 14 | factorial = 1; 15 | 16 | for (i = 1; i <= N;++i) { 17 | factorial *= i; 18 | } 19 | 20 | return factorial; 21 | } 22 | 23 | static double factorial3(int N) { 24 | int i; 25 | double factorial; 26 | 27 | factorial = 1; 28 | 29 | for (i = 1; i <= N; ++i) { 30 | factorial *= i; 31 | } 32 | 33 | return factorial; 34 | } 35 | 36 | double factorial(int N) { 37 | if (N > 40) { 38 | printf("This program is only valid for N <= 40 \n"); 39 | return -1.0; 40 | } 41 | double fact[41] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 42 | 20922789888000, 355687428096000, 6402373705728000, 121645100408832000, 2432902008176640000, 51090942171709440000.0, 1124000727777607680000.0, 43 | 25852016738884976640000.0, 620448401733239439360000.0, 15511210043330985984000000.0, 403291461126605635584000000.0, 10888869450418352160768000000.0, 44 | 304888344611713860501504000000.0, 8841761993739701954543616000000.0, 265252859812191058636308480000000.0, 8222838654177922817725562880000000.0, 45 | 263130836933693530167218012160000000.0, 8683317618811886495518194401280000000.0, 295232799039604140847618609643520000000.0, 10333147966386144929666651337523200000000.0, 46 | 371993326789901217467999448150835200000000.0, 13763753091226345046315979581580902400000000.0, 523022617466601111760007224100074291200000000.0, 47 | 20397882081197443358640281739902897356800000000.0, 815915283247897734345611269596115894272000000000.0 }; 48 | 49 | return fact[N]; 50 | 51 | } 52 | static void wave_function(int nk, double dt,int mother, double param,double scale1, double *kwave, double pi,double *period1, 53 | double *coi1, fft_data *daughter) { 54 | 55 | double norm, expnt, fourier_factor; 56 | int k, m; 57 | double temp; 58 | int sign,re; 59 | 60 | 61 | if (mother == 0) { 62 | //MORLET 63 | if (param < 0.0) { 64 | param = 6.0; 65 | } 66 | norm = sqrt(2.0*pi*scale1 / dt)*pow(pi,-0.25); 67 | 68 | for (k = 1; k <= nk / 2 + 1; ++k) { 69 | temp = (scale1*kwave[k-1] - param); 70 | expnt = -0.5 * temp * temp; 71 | daughter[k - 1].re = norm * exp(expnt); 72 | daughter[k - 1].im = 0.0; 73 | } 74 | for (k = nk / 2 + 2; k <= nk; ++k) { 75 | daughter[k - 1].re = daughter[k - 1].im = 0.0; 76 | } 77 | fourier_factor = (4.0*pi) / (param + sqrt(2.0 + param*param)); 78 | *period1 = scale1*fourier_factor; 79 | *coi1 = fourier_factor / sqrt(2.0); 80 | } 81 | else if (mother == 1) { 82 | // PAUL 83 | if (param < 0.0) { 84 | param = 4.0; 85 | } 86 | m = (int)param; 87 | norm = sqrt(2.0*pi*scale1 / dt)*(pow(2.0,(double)m) / sqrt((double)(m*factorial(2 * m - 1)))); 88 | for (k = 1; k <= nk / 2 + 1; ++k) { 89 | temp = scale1 * kwave[k - 1]; 90 | expnt = - temp; 91 | daughter[k - 1].re = norm * pow(temp,(double)m) * exp(expnt); 92 | daughter[k - 1].im = 0.0; 93 | } 94 | for (k = nk / 2 + 2; k <= nk; ++k) { 95 | daughter[k - 1].re = daughter[k - 1].im = 0.0; 96 | } 97 | fourier_factor = (4.0*pi) / (2.0 * m + 1.0); 98 | *period1 = scale1*fourier_factor; 99 | *coi1 = fourier_factor * sqrt(2.0); 100 | } 101 | else if (mother == 2) { 102 | if (param < 0.0) { 103 | param = 2.0; 104 | } 105 | m = (int)param; 106 | 107 | if (m % 2 == 0) { 108 | re = 1; 109 | } 110 | else { 111 | re = 0; 112 | } 113 | 114 | if (m % 4 == 0 || m % 4 == 1) { 115 | sign = -1; 116 | } 117 | else { 118 | sign = 1; 119 | } 120 | 121 | 122 | norm = sqrt(2.0*pi*scale1 / dt)*sqrt(1.0 / gamma(m + 0.50)); 123 | norm *= sign; 124 | 125 | if (re == 1) { 126 | for (k = 1; k <= nk; ++k) { 127 | temp = scale1 * kwave[k - 1]; 128 | daughter[k - 1].re = norm*pow(temp,(double)m)*exp(-0.50*pow(temp,2.0)); 129 | daughter[k - 1].im = 0.0; 130 | } 131 | } 132 | else if (re == 0) { 133 | for (k = 1; k <= nk; ++k) { 134 | temp = scale1 * kwave[k - 1]; 135 | daughter[k - 1].re = 0.0; 136 | daughter[k - 1].im = norm*pow(temp, (double)m)*exp(-0.50*pow(temp, 2.0)); 137 | } 138 | } 139 | fourier_factor = (2.0*pi) * sqrt(2.0 / (2.0 * m + 1.0)); 140 | *period1 = scale1*fourier_factor; 141 | *coi1 = fourier_factor / sqrt(2.0); 142 | } 143 | } 144 | 145 | void cwavelet(const double *y, int N, double dt, int mother, double param, double s0, double dj, int jtot, int npad, 146 | double *wave, double *scale, double *period, double *coi) { 147 | 148 | int i, j, k, iter; 149 | double ymean, freq1, pi, period1, coi1; 150 | double tmp1, tmp2; 151 | double scale1; 152 | double *kwave; 153 | fft_object obj, iobj; 154 | fft_data *ypad, *yfft,*daughter; 155 | 156 | pi = 4.0 * atan(1.0); 157 | 158 | if (npad < N) { 159 | printf("npad must be >= N \n"); 160 | exit(-1); 161 | } 162 | 163 | obj = fft_init(npad, 1); 164 | iobj = fft_init(npad, -1); 165 | 166 | ypad = (fft_data*)malloc(sizeof(fft_data)* npad); 167 | yfft = (fft_data*)malloc(sizeof(fft_data)* npad); 168 | daughter = (fft_data*)malloc(sizeof(fft_data)* npad); 169 | kwave = (double*)malloc(sizeof(double)* npad); 170 | 171 | ymean = 0.0; 172 | 173 | for (i = 0; i < N; ++i) { 174 | ymean += y[i]; 175 | } 176 | 177 | ymean /= N; 178 | 179 | for (i = 0; i < N; ++i) { 180 | ypad[i].re = y[i] - ymean; 181 | ypad[i].im = 0.0; 182 | } 183 | 184 | for (i = N; i < npad; ++i) { 185 | ypad[i].re = ypad[i].im = 0.0; 186 | } 187 | 188 | 189 | // Find FFT of the input y (ypad) 190 | 191 | fft_exec(obj, ypad, yfft); 192 | 193 | for (i = 0; i < npad; ++i) { 194 | yfft[i].re /= (double) npad; 195 | yfft[i].im /= (double) npad; 196 | } 197 | 198 | 199 | //Construct the wavenumber array 200 | 201 | freq1 = 2.0*pi / ((double)npad*dt); 202 | kwave[0] = 0.0; 203 | 204 | for (i = 1; i < npad / 2 + 1; ++i) { 205 | kwave[i] = i * freq1; 206 | } 207 | 208 | for (i = npad / 2 + 1; i < npad; ++i) { 209 | kwave[i] = -kwave[npad - i ]; 210 | } 211 | 212 | 213 | // Main loop 214 | 215 | for (j = 1; j <= jtot; ++j) { 216 | scale1 = scale[j - 1];// = s0*pow(2.0, (double)(j - 1)*dj); 217 | wave_function(npad, dt, mother, param, scale1, kwave, pi,&period1,&coi1, daughter); 218 | period[j - 1] = period1; 219 | for (k = 0; k < npad; ++k) { 220 | tmp1 = daughter[k].re * yfft[k].re - daughter[k].im * yfft[k].im; 221 | tmp2 = daughter[k].re * yfft[k].im + daughter[k].im * yfft[k].re; 222 | daughter[k].re = tmp1; 223 | daughter[k].im = tmp2; 224 | } 225 | fft_exec(iobj, daughter, ypad); 226 | iter = 2 * (j - 1) * N; 227 | for (i = 0; i < N; ++i) { 228 | wave[iter + 2 * i] = ypad[i].re; 229 | wave[iter + 2 * i + 1] = ypad[i].im; 230 | } 231 | } 232 | 233 | 234 | for (i = 1; i <= (N + 1) / 2; ++i) { 235 | coi[i - 1] = coi1 * dt * ((double)i - 1.0); 236 | coi[N - i] = coi[i - 1]; 237 | } 238 | 239 | 240 | 241 | free(kwave); 242 | free(ypad); 243 | free(yfft); 244 | free(daughter); 245 | 246 | free_fft(obj); 247 | free_fft(iobj); 248 | 249 | } 250 | 251 | void psi0(int mother, double param,double *val,int *real) { 252 | double pi,coeff; 253 | int m,sign; 254 | 255 | m = (int)param; 256 | pi = 4.0 * atan(1.0); 257 | 258 | if (mother == 0) { 259 | // Morlet 260 | *val = 1.0 / sqrt(sqrt(pi)); 261 | *real = 1; 262 | } 263 | else if (mother == 1) { 264 | //Paul 265 | if (m % 2 == 0) { 266 | *real = 1; 267 | } 268 | else { 269 | *real = 0; 270 | } 271 | 272 | if (m % 4 == 0 || m % 4 == 1) { 273 | sign = 1; 274 | } 275 | else { 276 | sign = -1; 277 | } 278 | *val = sign * pow(2.0, (double)m) * factorial(m) / (sqrt(pi * factorial(2 * m))); 279 | 280 | } 281 | else if (mother == 2) { 282 | // D.O.G 283 | *real = 1; 284 | 285 | if (m % 2 == 0) { 286 | if (m % 4 == 0) { 287 | sign = -1; 288 | } 289 | else { 290 | sign = 1; 291 | } 292 | coeff = sign * pow(2.0, (double)m / 2) / gamma(0.5); 293 | *val = coeff * gamma(((double)m + 1.0) / 2.0) / sqrt(gamma(m + 0.50)); 294 | } 295 | else { 296 | *val = 0; 297 | } 298 | } 299 | } 300 | 301 | static int maxabs(double *array,int N) { 302 | double maxval,temp; 303 | int i,index; 304 | maxval = 0.0; 305 | index = -1; 306 | 307 | for (i = 0; i < N; ++i) { 308 | temp = fabs(array[i]); 309 | if (temp >= maxval) { 310 | maxval = temp; 311 | index = i; 312 | } 313 | } 314 | 315 | return index; 316 | } 317 | 318 | 319 | double cdelta(int mother, double param, double psi0 ) { 320 | int N,i,j,iter; 321 | double *delta, *scale,*period,*wave,*coi,*mval; 322 | double den,cdel; 323 | double subscale,dt,dj,s0; 324 | int jtot; 325 | int maxarr; 326 | 327 | subscale = 8.0; 328 | dt = 0.25; 329 | if (mother == 0) { 330 | N = 16; 331 | s0 = dt/4; 332 | } 333 | else if (mother == 1) { 334 | N = 16; 335 | s0 = dt / 4.0; 336 | } 337 | else if (mother == 2) 338 | { 339 | s0 = dt/8.0; 340 | N = 256; 341 | if (param == 2.0) { 342 | subscale = 16.0; 343 | s0 = dt / 16.0; 344 | N = 2048; 345 | } 346 | } 347 | 348 | dj = 1.0 / subscale; 349 | jtot = 16 * (int) subscale; 350 | 351 | delta = (double*)malloc(sizeof(double)* N); 352 | wave = (double*)malloc(sizeof(double)* 2 * N * jtot); 353 | coi = (double*)malloc(sizeof(double)* N); 354 | scale = (double*)malloc(sizeof(double)* jtot); 355 | period = (double*)malloc(sizeof(double)* jtot); 356 | mval = (double*)malloc(sizeof(double)* N); 357 | 358 | 359 | delta[0] = 1; 360 | 361 | for (i = 1; i < N; ++i) { 362 | delta[i] = 0; 363 | } 364 | 365 | for (i = 0; i < jtot; ++i) { 366 | scale[i] = s0*pow(2.0, (double)(i)*dj); 367 | } 368 | 369 | cwavelet(delta, N, dt, mother, param, s0, dj, jtot, N, wave, scale, period, coi); 370 | 371 | for (i = 0; i < N; ++i) { 372 | mval[i] = 0; 373 | } 374 | 375 | for (j = 0; j < jtot; ++j) { 376 | iter = 2 * j * N; 377 | den = sqrt(scale[j]); 378 | for (i = 0; i < N; ++i) { 379 | mval[i] += wave[iter + 2 * i]/den; 380 | } 381 | } 382 | 383 | 384 | maxarr = maxabs(mval, N); 385 | 386 | cdel = sqrt(dt) * dj * mval[maxarr] / psi0; 387 | 388 | free(delta); 389 | free(wave); 390 | 391 | free(scale); 392 | free(period); 393 | free(coi); 394 | free(mval); 395 | 396 | return cdel; 397 | } 398 | 399 | void icwavelet(double *wave, int N, double *scale,int jtot,double dt,double dj,double cdelta,double psi0,double *oup) { 400 | int i, j,iter; 401 | double den, coeff; 402 | 403 | coeff = sqrt(dt) * dj / (cdelta *psi0); 404 | 405 | for (i = 0; i < N; ++i) { 406 | oup[i] = 0.0; 407 | } 408 | 409 | for (j = 0; j < jtot; ++j) { 410 | iter = 2 * j * N; 411 | den = sqrt(scale[j]); 412 | for (i = 0; i < N; ++i) { 413 | oup[i] += wave[iter + 2 * i] / den; 414 | } 415 | } 416 | 417 | for (i = 0; i < N; ++i) { 418 | oup[i] *= coeff; 419 | } 420 | } 421 | -------------------------------------------------------------------------------- /src/util/matrix.h: -------------------------------------------------------------------------------- 1 | #ifndef MATRIX_H__ 2 | #define MATRIX_H__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include "exception.h" 9 | 10 | namespace mx{ 11 | 12 | #define _FMX(X,args...) (float[]){X, ##args} 13 | #define _DMX(X,args...) (double[]){X, ##args} 14 | #define _IMX(X,args...) (int[]){X, ##args} 15 | 16 | template 17 | class Matrix{ 18 | private: 19 | union{ 20 | int cols; 21 | int width; 22 | }; 23 | union{ 24 | int rows; 25 | int height; 26 | }; 27 | private: 28 | T data[D1][D2]; 29 | public: 30 | Matrix(){height = D1; width = D2;} 31 | Matrix(const Matrix& m){height = D1; width = D2;memcpy(data, m.data, sizeof(T)*rows*cols);} 32 | Matrix(const T* pm){height = D1; width = D2;memcpy(data, pm, sizeof(T)*rows*cols);} 33 | public: 34 | inline int Width() const{return width;} 35 | inline int Cols() const{return cols;} 36 | inline int Height() const{return height;} 37 | inline int Rows() const{return rows;} 38 | inline T& V(int x, int y){return data[x][y];} 39 | inline T V(int x, int y) const{return data[x][y];} 40 | //if is column matrix. also be seen as [a,...,d] 41 | inline T& V(int x){assert(cols == 1); return data[x][0];} 42 | inline T V(int x) const{assert(cols == 1); return data[x][0];} 43 | //access the data as array 44 | inline T& D(int x){assert(x>=0 && x=0 && xd){ 63 | d = p; 64 | pnRow[k] = i; 65 | pnCol[k] = j; 66 | } 67 | } 68 | } 69 | // failed 70 | if(d == 0.0){ 71 | delete [] pnRow; delete [] pnCol; 72 | return false; 73 | } 74 | 75 | if(pnRow[k] != k){ 76 | for(int j = 0; j <= D1-1; j++){ 77 | p = data[k][j]; 78 | data[k][j] = data[pnRow[k]][j]; 79 | data[pnRow[k]][j] = p; 80 | } 81 | } 82 | 83 | if(pnCol[k] != k){ 84 | for(int i = 0; i <= D1-1; i++){ 85 | p = data[i][k]; 86 | data[i][k] = data[i][pnCol[k]]; 87 | data[i][pnCol[k]] = p; 88 | } 89 | } 90 | 91 | data[k][k] = 1/data[k][k]; 92 | for(int j = 0; j <= D1-1; j++){ 93 | if(j != k){ 94 | data[k][j] *= data[k][k]; 95 | } 96 | } 97 | 98 | for(int i = 0; i <= D1-1; i++){ 99 | if(i != k){ 100 | for(int j = 0; j <= D1-1; j++){ 101 | if(j != k){ 102 | data[i][j] -= data[i][k]*data[k][j]; 103 | } 104 | } 105 | } 106 | } 107 | 108 | for(int i = 0; i <= D1-1; i++){ 109 | if(i != k){ 110 | data[i][k] *= -data[k][k]; 111 | } 112 | } 113 | } 114 | //swap rows and columns 115 | for(int k = D1-1; k>= 0; k--){ 116 | if(pnCol[k] != k){ 117 | for(int j = 0; j <= D1-1; j++){ 118 | p = data[k][j]; 119 | data[k][j] = data[pnCol[k]][j]; 120 | data[pnCol[k]][j] = p; 121 | } 122 | } 123 | 124 | if(pnRow[k] != k){ 125 | for(int i = 0; i <= D1-1; i++){ 126 | p = data[i][k]; 127 | data[i][k] = data[i][pnRow[k]]; 128 | data[i][pnRow[k]] = p; 129 | } 130 | } 131 | } 132 | 133 | delete[] pnRow; 134 | delete[] pnCol; 135 | 136 | return true; 137 | } 138 | 139 | void Print(std::ostream& s) const 140 | { 141 | s<& operator = (const Matrix& m) 151 | { 152 | assert(rows == m.rows && cols == m.cols); 153 | // copy the pointer 154 | memcpy(data, m.data, sizeof(T)*rows*cols); 155 | 156 | return *this; 157 | } 158 | 159 | const Matrix& operator = (const T* pm) 160 | { 161 | memcpy(data, pm, sizeof(T)*rows*cols); 162 | return *this; 163 | } 164 | 165 | const Matrix& operator *= (T v) 166 | { 167 | for(int i = 0; i < rows; i++){ 168 | for (int j = 0; j < cols; j++){ 169 | data[i][j] *= v; 170 | } 171 | } 172 | 173 | return *this; 174 | } 175 | 176 | public: 177 | template 178 | friend void Product333(const Matrix<3,3,K>& src1, const Matrix<3,3,K>& src2, Matrix<3,3,K>* destin); 179 | template 180 | friend void Product444(const Matrix<4,4,K>& src1, const Matrix<4,4,K>& src2, Matrix<4,4,K>* destin); 181 | template 182 | friend void Product121(const Matrix<1,2,K>& src1, const Matrix<2,1,K>& src2, Matrix<1,1,K>* destin); 183 | template 184 | friend void Product131(const Matrix<1,3,K>& src1, const Matrix<3,1,K>& src2, Matrix<1,1,K>* destin); 185 | template 186 | friend void Product331(const Matrix<3,3,K>& src1, const Matrix<3,1,K>& src2, Matrix<3,1,K>* destin); 187 | template 188 | friend void Product341(const Matrix<3,4,K>& src1, const Matrix<4,1,K>& src2, Matrix<3,1,K>* destin); 189 | template 190 | friend void Product441(const Matrix<4,4,K>& src1, const Matrix<4,1,K>& src2, Matrix<4,1,K>* destin); 191 | 192 | }; 193 | 194 | template 195 | void Product333(const Matrix<3,3,T>& src1, const Matrix<3,3,T>& src2, Matrix<3,3,T>* destin) 196 | { 197 | destin->data[0][0] = src1.data[0][0]*src2.data[0][0]+src1.data[0][1]*src2.data[1][0]+src1.data[0][2]*src2.data[2][0]; 198 | destin->data[0][1] = src1.data[0][0]*src2.data[0][1]+src1.data[0][1]*src2.data[1][1]+src1.data[0][2]*src2.data[2][1]; 199 | destin->data[0][2] = src1.data[0][0]*src2.data[0][2]+src1.data[0][1]*src2.data[1][2]+src1.data[0][2]*src2.data[2][2]; 200 | 201 | destin->data[1][0] = src1.data[1][0]*src2.data[0][0]+src1.data[1][1]*src2.data[1][0]+src1.data[1][2]*src2.data[2][0]; 202 | destin->data[1][1] = src1.data[1][0]*src2.data[0][1]+src1.data[1][1]*src2.data[1][1]+src1.data[1][2]*src2.data[2][1]; 203 | destin->data[1][2] = src1.data[1][0]*src2.data[0][2]+src1.data[1][1]*src2.data[1][2]+src1.data[1][2]*src2.data[2][2]; 204 | 205 | destin->data[2][0] = src1.data[2][0]*src2.data[0][0]+src1.data[2][1]*src2.data[1][0]+src1.data[2][2]*src2.data[2][0]; 206 | destin->data[2][1] = src1.data[2][0]*src2.data[0][1]+src1.data[2][1]*src2.data[1][1]+src1.data[2][2]*src2.data[2][1]; 207 | destin->data[2][2] = src1.data[2][0]*src2.data[0][2]+src1.data[2][1]*src2.data[1][2]+src1.data[2][2]*src2.data[2][2]; 208 | } 209 | 210 | template 211 | void Product444(const Matrix<4,4,T>& src1, const Matrix<4,4,T>& src2, Matrix<4,4,T>* destin) 212 | { 213 | destin->data[0][0] = src1.data[0][0]*src2.data[0][0]+src1.data[0][1]*src2.data[1][0]+src1.data[0][2]*src2.data[2][0]+src1.data[0][3]*src2.data[3][0]; 214 | destin->data[0][1] = src1.data[0][0]*src2.data[0][1]+src1.data[0][1]*src2.data[1][1]+src1.data[0][2]*src2.data[2][1]+src1.data[0][3]*src2.data[3][1]; 215 | destin->data[0][2] = src1.data[0][0]*src2.data[0][2]+src1.data[0][1]*src2.data[1][2]+src1.data[0][2]*src2.data[2][2]+src1.data[0][3]*src2.data[3][2]; 216 | destin->data[0][3] = src1.data[0][0]*src2.data[0][3]+src1.data[0][1]*src2.data[1][3]+src1.data[0][2]*src2.data[2][3]+src1.data[0][3]*src2.data[3][3]; 217 | 218 | destin->data[1][0] = src1.data[1][0]*src2.data[0][0]+src1.data[1][1]*src2.data[1][0]+src1.data[1][2]*src2.data[2][0]+src1.data[1][3]*src2.data[3][0]; 219 | destin->data[1][1] = src1.data[1][0]*src2.data[0][1]+src1.data[1][1]*src2.data[1][1]+src1.data[1][2]*src2.data[2][1]+src1.data[1][3]*src2.data[3][1]; 220 | destin->data[1][2] = src1.data[1][0]*src2.data[0][2]+src1.data[1][1]*src2.data[1][2]+src1.data[1][2]*src2.data[2][2]+src1.data[1][3]*src2.data[3][2]; 221 | destin->data[1][3] = src1.data[1][0]*src2.data[0][3]+src1.data[1][1]*src2.data[1][3]+src1.data[1][2]*src2.data[2][3]+src1.data[1][3]*src2.data[3][3]; 222 | 223 | destin->data[2][0] = src1.data[2][0]*src2.data[0][0]+src1.data[2][1]*src2.data[1][0]+src1.data[2][2]*src2.data[2][0]+src1.data[2][3]*src2.data[3][0]; 224 | destin->data[2][1] = src1.data[2][0]*src2.data[0][1]+src1.data[2][1]*src2.data[1][1]+src1.data[2][2]*src2.data[2][1]+src1.data[2][3]*src2.data[3][1]; 225 | destin->data[2][2] = src1.data[2][0]*src2.data[0][2]+src1.data[2][1]*src2.data[1][2]+src1.data[2][2]*src2.data[2][2]+src1.data[2][3]*src2.data[3][2]; 226 | destin->data[2][3] = src1.data[2][0]*src2.data[0][3]+src1.data[2][1]*src2.data[1][3]+src1.data[2][2]*src2.data[2][3]+src1.data[2][3]*src2.data[3][3]; 227 | 228 | destin->data[3][0] = src1.data[3][0]*src2.data[0][0]+src1.data[3][1]*src2.data[1][0]+src1.data[3][2]*src2.data[2][0]+src1.data[3][3]*src2.data[3][0]; 229 | destin->data[3][1] = src1.data[3][0]*src2.data[0][1]+src1.data[3][1]*src2.data[1][1]+src1.data[3][2]*src2.data[2][1]+src1.data[3][3]*src2.data[3][1]; 230 | destin->data[3][2] = src1.data[3][0]*src2.data[0][2]+src1.data[3][1]*src2.data[1][2]+src1.data[3][2]*src2.data[2][2]+src1.data[3][3]*src2.data[3][2]; 231 | destin->data[3][3] = src1.data[3][0]*src2.data[0][3]+src1.data[3][1]*src2.data[1][3]+src1.data[3][2]*src2.data[2][3]+src1.data[3][3]*src2.data[3][3]; 232 | } 233 | 234 | template 235 | void Product121(const Matrix<1,2,T>& src1, const Matrix<2,1,T>& src2, Matrix<1,1,T>* destin) 236 | { 237 | destin->data[0][0] = src1.data[0][0]*src2.data[0][0]+src1.data[0][1]*src2.data[1][0]; 238 | } 239 | 240 | template 241 | void Product131(const Matrix<1,3,T>& src1, const Matrix<3,1,T>& src2, Matrix<1,1,T>* destin) 242 | { 243 | destin->data[0][0] = src1.data[0][0]*src2.data[0][0]+src1.data[0][1]*src2.data[1][0]+src1.data[0][2]*src2.data[2][0]; 244 | } 245 | 246 | template 247 | void Product331(const Matrix<3,3,T>& src1, const Matrix<3,1,T>& src2, Matrix<3,1,T>* destin) 248 | { 249 | destin->data[0][0] = src1.data[0][0]*src2.data[0][0]+src1.data[0][1]*src2.data[1][0]+src1.data[0][2]*src2.data[2][0]; 250 | destin->data[1][0] = src1.data[1][0]*src2.data[0][0]+src1.data[1][1]*src2.data[1][0]+src1.data[1][2]*src2.data[2][0]; 251 | destin->data[2][0] = src1.data[2][0]*src2.data[0][0]+src1.data[2][1]*src2.data[1][0]+src1.data[2][2]*src2.data[2][0]; 252 | } 253 | 254 | template 255 | void Product341(const Matrix<3,4,T>& src1, const Matrix<4,1,T>& src2, Matrix<3,1,T>* destin) 256 | { 257 | destin->data[0][0] = src1.data[0][0]*src2.data[0][0]+src1.data[0][1]*src2.data[1][0]+src1.data[0][2]*src2.data[2][0]+src1.data[0][3]*src2.data[3][0]; 258 | destin->data[1][0] = src1.data[1][0]*src2.data[0][0]+src1.data[1][1]*src2.data[1][0]+src1.data[1][2]*src2.data[2][0]+src1.data[1][3]*src2.data[3][0]; 259 | destin->data[2][0] = src1.data[2][0]*src2.data[0][0]+src1.data[2][1]*src2.data[1][0]+src1.data[2][2]*src2.data[2][0]+src1.data[2][3]*src2.data[3][0]; 260 | } 261 | 262 | template 263 | void Product441(const Matrix<4,4,T>& src1, const Matrix<4,1,T>& src2, Matrix<4,1,T>* destin) 264 | { 265 | destin->data[0][0] = src1.data[0][0]*src2.data[0][0]+src1.data[0][1]*src2.data[1][0]+src1.data[0][2]*src2.data[2][0]+src1.data[0][3]*src2.data[3][0]; 266 | destin->data[1][0] = src1.data[1][0]*src2.data[0][0]+src1.data[1][1]*src2.data[1][0]+src1.data[1][2]*src2.data[2][0]+src1.data[1][3]*src2.data[3][0]; 267 | destin->data[2][0] = src1.data[2][0]*src2.data[0][0]+src1.data[2][1]*src2.data[1][0]+src1.data[2][2]*src2.data[2][0]+src1.data[2][3]*src2.data[3][0]; 268 | destin->data[3][0] = src1.data[3][0]*src2.data[0][0]+src1.data[3][1]*src2.data[1][0]+src1.data[3][2]*src2.data[2][0]+src1.data[3][3]*src2.data[3][0]; 269 | } 270 | 271 | } 272 | 273 | #endif -------------------------------------------------------------------------------- /example/002a08b9-0248-4929-9759-2d5c0942076d.fasta: -------------------------------------------------------------------------------- 1 | >002a08b9-0248-4929-9759-2d5c0942076d|0 ground_truch 2 | GGAAAACGTTCCTTTCGCGCATGTTCGGCAATCAGCCCGATCAGTGGCAGCAGGGATTGAGCGACGAGGATCGCCAGCGTCTCACCATCAACGCGCTGACCCGTATGCGCTTCTGCACGGCAGACGGGCGCATCGACTTCAAGATCAAGGAAGGTGCCGATGCCGCGACCACCGAGCTCAAGCCGTGGTTCGATGCGCCGGGCCGCCGCACGGCCGATGTCACCGTGGTGTTCGGTCACTGGTCGGCGCTCGGTCTGGTCATGCGCGAGAACGTCCTCGGACTCGATACCGGCTGCGTCTGGGGAGGCAAATTGACGGCGGTGAAGCTCGCCAGCGTCCCTGCCGAACGCGAGCTGATTCAGATCGATTGCCCGCAGATTCGCGATCCTTTTGCGCTGGCCGACGCCAAGAAGCGCGCCAAGATGAAGAAGGCCGATAAGGCCGAAGAGGCCTTCAAAGCTGCAAAAGCCGAGAAGATCGGCAAGGGCGCACGCAAGCTCGACAAGACCGATAAACCCGCAAAAGCCGACAAGACGGCGAAACGCAAAGGCGAATGAGGCGGGACTTGCCCCATCCGCTCACGTCTGTGCCTCACGTCTCGATCAAATAAAAAACGGCGCATTCACGCGCCGTTTTTTGTTCCGCCAGACTTCGCGTCAGGCCTGAACCGCCTGTGCGGCATCGCCCTCTTCGTCACCCAAGACCGCATCGCGCGAACCGACCGAACCACTCTGCGGAAGCACCACTTCCGGCAGGAAGGCCTGCAACGCGTCGCCAACGGCTTTCTGCGCGCCGAGCGCGAACTCGCGTCGATGCTGCCCATCCCTCGGATATTGCGGCTCGCCGACCGACAGTCGTACCGTCATCGGCGGTGCGCGCAGAATCATGTCGATGGACTCGATCAGACTCATCTCGCCAATGTAAGCCGGGGCCATCGTATGGCGTCCGCTCGACGCATCGGTGTAGAACAGGCAAAGCGGCTGCACGGGCTTCCCGGTACTCACCGGGGCTTGCAGCAGGTTGGCGTGAAACGGCAACAGGCTACGGCCATCCGTCGTCGTGCCTTCCGGGAAGACCGTAATGATGTCGCCGTCACGCAGACAATCCGACAGGTAGTGCATGATGCGGCGCGCATCGGCGCGGCGCTCACGTTGCAGGAAAATCGTCCGCGTCTGCACGCACAGCCAACCGACCAGCGGCCAATGGCGAATCTCGGCCTTCGCGACGAAGCGCACGGGTTGCCACGCATTGATCGCGAAGATGTCGATCCACGACACGTGATTGCACAGAAGCATGACGCCGCTGTCGGGCAACGCCGCGTGTTGCTCGACTTCCAGACGCATGCCGCACAGCTTCAGCAGCTTCTGCGACCACGCGCGAATGCGGCGATGCTTCGCCGCCTCGGTCAGAAACGGGAAGCACAACAACGCAGTGAGCAGACCGCGCGAGAGGTGCAGACCGAGACGGAGTTTTTTGATCAAGAGCACGGCAATCGCATCCTAAACGGCAGGGGCTTCGTGCGCCACGCGGCCACCCACCAGCGTGAGACGTACGCGCCCCGGCAATTCGTATCCCAGAAACGGGGTGTTATGACCGGCGCTGCGCAAATTCGGCGCGGCCACCGTCCAATGCGCCAACGGCGCGAATACACAAACATCGGCTGGCTGTCCCGGCGCAAGACGGCCAGCCCCCGACGCGACTTGCGCGAGACGCTGCCCTGGCGAGTGCGTCACACGCGCCAACGCGTCGACCAGCGGCACGCGCGACTCCTCGGCCCATTTCAGCACCAGCGACAGCAACAACTCCAGCCCGCTTGCGCCCGGCGAGGCTTCTGCAAATGGCACCAGACGGGCATCGGCAGCCAGCGGCGTATGGTCGGAGCAGATGGCGTCAATCGTACCGTCTCGCACCGCATCCCGGATGGCCTCCCGGTCGCGCTGGCCTCTTAGCGGCGGATCGAGCCGGTACTGGACATCAAAATAACCGATGTCCATGTCCGTCAGATGGAGATGGTGCGCGGCAACGTCGCACGTCACAGGCAACCCCTCGGCCTTTGCCGCACGCACGATCGCCAACCCTGCGGCAGACGACAGACGACACAGATGCACTCGCGTACCCGTGGCGCGCACGAGTTCGAGAATCGTATGGAGCGCAATGGTCTCGGCAACGACGGGAATCCCGGCAAGGCCAAGGCGCGATGCGACGGCCCCACTGGCCGCCACGCCACCGGCAGCCAACGCGGCATCCTGTGCGCGTAGCCATACCGTCAGTCCGAACGTGCCCGCGTATTGCAACGCGCGCAGCAACGTGCGGGGGTCGGTCATCGATGCGTTGGCCTGCGAGAGTCCGATGCAGCCCGCCTGCGTCAACTGCGCCATTTCCGTGAGTTCGCGCCCAGCGAGGCCAACGCTCAGCGCGCCCAGCGGATGGACTTGCACAAGATGAGCCGCACGAGCACGTAATTGCAGCATCTCGACAAGGTCGGGCTCATCGAGCACGGGGTCGGTATCCGGCGGGCAAACGACGCGCGTCACGCCACCGGCGAGTGCCGCCGCCGCTTCGCTGGCTGCCGTCACTCGGCGCGCGGCCAGATCGACGAGTCCGGGCATGACCACCAGCCCCGTCGCATCGAACACCCGTTCGGCCGTGAAATCGGCGGGTGCCTCGCCCAGCGCCCCGATATGACCGTCGGCGATGAAAACGTCCTGAACCCGGTCGGTTCGCGTCGCGGGATCGATGACACGGCCACCCTTCAGATGCAATTTCATGCTGCGCTCACCCGTGGTTTGCGGCGACGATGCTCATCACCGCCATGCGCACGGCGATGCCGAACGACACTTGTTCGAGAATGACCGAGTGCGGGCCATCGGCCACCGCCGAATCGATCTCCACGCCGCGATTCATCGGCCCCGGATGCATGACGATGACGTCCGGCCTGGCCAGTGCCAAGCGCTCGGGCGTCAAGCCGTAATACTTGAAGTACTCGGCCGCCGATGGCAGCAACGCACCGTTCATTCGCTCGTTCTGCAACCGCAACATAATGACGACATCGACATCGCGAAGTCCTTCGTCCATGTCGTGAAACACACGCACGCCGAGTTGTTCGAGTCCGGTGGGCAGAAGCGTACGCGGACCGATCGCGCGCACTTCCGGCACGCCCAGCGTAGTGAGCGCGTGAATATCGGAACGCGCCACCCGCGAATGCAGAATGTCGCCGACGATGGCGACCGTCAGGTTCTGGAATTCGCCCTTGTGATGGCGAATCGTGTACATGTCGAGCAAACCCTGCGTGGGGTGCGCGTGCCGTCCGTCGCCCGCGTTGATGACATGCACATGCGGCGCGCAATGCTCGGCAATCAGGTATGGCGCCCCCGACTGCGCGTGACGCACGACGAACAGATCCGCATGCATCGCCGACAGGTTGCCGATGGTGTCGAGCAATGTCTCGCCCTTGCTCGTCGACGACGCGTTGATATTCAGATTCAGCACATCGGCCGACAAGCGCGCTGCGGCGATCTCAAACGTCGTTCGCGTACGCGTGGAATTCTCGAAGAAGAGATTGAAGACCGACTTGCCGCTCAGCAGCGGCACCTTCTTGACGTCCGCATCGTTCACGCTGACGAACTGCGTGGCCGTGTCGAGAATGTGCATCAGCACGGCGCGCGGCAATCCTTCCACCGTCAGCAAATGCTTCAGTTCACCGTGACGGTTGAGCTGGGGATGGCCACGTCGGCCGAGAATTCCGTTAGCCATACAGGGGAGATGCCTTGCCAACGCCGCGTGGCGCGACGTCGCTCAGAAAACTGCGGGGCGCGATGCCCGCCGGGAGGTCAGGCAGGCACATGCTCGTCGAAATACTGCTGAAGGATGATGCGGGCGGCTTCGGCGTCGAGCGATGTCTTTTGGGACAGCTTGACGCCCGCCTCGGCCAGCGCTGCCGCAGCGGCGACCGACGAGTAGCGTTCGTCGACCCACACGACCGGCACGTCAAATCGCCCGTTGAGTTGATTCCCGAAGCGCTTGGCTTGTTGGGTCATCGCGTGCGGCGTACCGTCCGGATGACACGGCAGCCCGACGACGATCAGTTCGGGTTGCCATTCTGCAATGAGCTTGCCGGTCTCGGCGAAGCGAACTTCGCGATTGAGATTGGCAAGAACGGTGAGGGCGCGAGCCTCGCGCAACAGGAGATTGCCGATCGCCACGCCGATCCGGCGCTCGCCGTAATCGAAGGCGAGTACCGTGGCACTGCCAGCCGTCATGCGTGACCTGCGTCGGCGGAGAGCATCGACGACGTCACACCCAGCAGTGCCAGCGCGGCGTCGAAGCGTTCGGCCGGCGGCACATCGAATACGATGCCCGGGTCAGCGGCGACGGTCAGCCAGCCATTGCGGCCGATCTCGTCTTCCAGTTGGCCGGCGCTCCAGCCCGAATGCCCGAGCGTCAGCAGAAAGCGATTCGGCCCCTGTCCATTGGCCACGGCTTCGAGCACGTCTTTCGACGTCGTCATCTCGAGGCCACCCGGCACCGACAGCGACGAGCTATACGCCGTGCCGGTCGACTCGTGCAGCACGAAACCGCGCTCGGTCTGTACCGGACCGCCGAAGAACACCGGTTGATGCGCCAGTGGATCGATTTCCAGCTTCAGGTCGAGACGCTCGAACAGCGACTGCAAATCAATGTCGGTCGGACGATTGATGACCAGCCCGATCGCGCCTTTTTCACTGTGCTCGCACAGGTACACGACGGTGCCGGAAAAGGTCGGATCGGCCATGCCGGGCATGGCGATAAGGAACTGATTCGTGAGATTGATACGGTCGTTCGGCATAGGGCCAAAGTTTATCGGAACCTGTTTGACGGTCTGCCGCGCGGTGTCGCACTCCGCAGCAGGGGCATGGCCCCCGCGCGGGCTCGCAGCACCTGCCTGCGGCCGGTCAGCGGACGAACTTTTTCCGCATCGTGGTACGGCGATCGGCCGCCAAAGGCGACCTTTGCGCCGACTTTATCACGGAACGTCGCGCCCGGTGACGAGCCGCTGTCCGAACACGCTGGCGTCCAGCGCGCGCTCTCGCCACATCGCCATGTCGGCGATCAGGTCAGGTCGCGATTCGGGGTACGTGTCGGCCGCGAACTGGTGAAGCATGCCGCGCAACGCCTTGACGGTCATCGCAAGCGCTGCGGGCCCGCCCGGCTCCGCTGGCGGCGAAGCCGCAAGTCGCTCGCCCGTGGCGGCGACCGCCGCCGCAAGCCGCGCAACCGGAGCCAGTCCGATCGCCGCAGAGTATTCCGCGACCTTGGCGGCCACCGCAGGATCGTTCAAATTCGGAAGTGCCTCATCGGCGAGGCTGAGAAACGTTTGGCAAACGTCCTGCCGCACCGCCAACGGGCCGATGCGCAGCCAGTCGCGCGAGCTATTGCCCGCGCCCTGCTTCTGCGCCGCCTGTGCAGCATCCACCAACGGCTCGGGCAAATGACCGGGACGGCGCAGCACGCCGAAGTCGGCCAGCAACGTACCCAACCAGCTATCGGGGGCCTGCGCATGCCAGGTGGCGAGGGCTTCGAGCAGATCGTGCCCTGGCACCGCCTCGCCGCCGCCCTTCGCGCCTGTGCCCGCCGCGGCGGACGATGCGCTCTGAACGTCTCCCGGCGCACTCGGACGCGTCAATTGCTTACGCAGCGCCAGATTCATCCGCCCGATCTGGCGTTTGTCGGCCAGACTCAGCGGGGCACGCGCAAAGCGCAGCCACGCGGCGGCCAGACGCCAGTAGTCGAGCGGTGCCGTCGCCCCGGCGCGGTGGAGGTCGGCGGCAAGATCGGCCAATTGCGCGAGCGCCGCCGTGGTATCGGTCGCCTCCGCATCTGGACGCAACAGGCGCAGCAGAACGCGTTCGACGTCGGCACGCAGCGGTGCAGTGCCAACGGGCAGCCCATGTAGTCGCGGCTGTGCCACCACCCATCCCGCCATCCGAAGCTCGCCCGGCGACGGGGCGCCGGACCAGTTCTCAGAAGGCGCGGCGGCATCCGTCGATGCGGGCGTGGCGGCAGGGATGGCCCCCGCCTGCCAGATGTCGCGCTCGAACCGGCGCAGCGCGTTGCGCTGTGCGTCCTGGCCGCCCGGCTCCCCATATGCCGCCTCGGCGATCGCCTGCACAAGACGCTCGCCGTGCAGCGCCCAGTCGGCATGACCGCTCGACTGGAGCAGACGATTGGCGCGCCGCAACGGCCCAAGCGCAGCGGCGGGACCGTTGGACCAGGCGTCGGACGCCTCGGTCAGCGCTTCGGCCACCTCGGGCAGACGCCACAAGGGGGTCGTGTCACGCGTCTCGCGCGTTGCAGTTCCGGGGGTGTTGATGGTGGTGTCGGAAGGCGTTTGCGGCGTCACCATAGGCCATCTCCTGGCCGTGCGGCCGGTCTTCGTGAATTCGGGCGGGAAATCCGCCGCGTCACCGGCCGGGCCGATGGCCGGGCGGATCGTCGAGCGCTGTGCCGCACCCGGGGCTTAACGGCGTTGGCAGGCATCGGGGAGCGCGGCAAACACGCGGGCATCTCGGAGAAATGGCGGCTGAGCCGCCCATCCTCAGATTTGCACCATCTCGAAGTCTTCCTTGCGCGCGCCGCACTCGGGGCAGGTCCAGTTGATAGGCACGTCGTCCCAGCGCGTGCCGGGCGCAATGCCCTCGTCGGGCAAACCTGCCTCTTCGTCATAAATCCAACCGCAAATGAGGCACATCCAGCTCTTGTATTCCATTCTTTCTTCAGCGACGAGCGTTCCGTTACAATGGCTTGTCAACCGCTTCGGGTCCCGCCGGCAGAGATGTCGTGCGGTGTTGTGGGAACCCTGCCGGGGCATTGTCCGGACAGGGGGTGCCCACGGCGCTTTTCAGCGCTCCGAAACGGGCATTTAAGGCGTGATGGTACCAACGAACCCAAGGCCTGACCAGATCGCCGTCTATCCTGCCTCCATGCACACTGAATCCCCTCCCATTCTTCTGACCTTCGGGCTCTCCGACCCCACCTCGGCAACCGGCGTCCAGGCCGACCTGCTGACCTTTGCCAGCATGGGTGGCTACGGCGTGTCGGTGCTGACCGGCTACTCCTCTCAGGACTCACGCGCGTGCGATGAAGTGCAGCCGATCGATCCGGACTGGATCGCCGATCAGGCGCGCATGCTGCTCGAAGACATGCCGGTCGCCGCCTTCAAGGTCGGCAGCACGATTAACGCCGAAAATGTCGCCGCGATTGCCGAGATCGTGGCCGATTACGACGAGACGCCTCTGGTCGTCGCGCCCGACTTCGGGCTGGCGGGCGAGCATCTGCTCTCGGCCGACGAGTTGCGCGAGGCCACGGCCAGTCTTCTCGTACCGCAAGCCAGTGTGCTGGTCGTGAGCCCTGCCAGCGCCGTGGCCCTAGCGCAGACCATCACCGAAAACGAGAATATCTCGCTCGACGAAGCGGTCTCCATCCTGCTGGAAAACGGTTGCGAGTTCATCTTGGTGAGCGACAGCAACGCACCGCAATTCACGCACACGCTGTATGCCGATGGCGGCGTCGTTCGCGAAGACGCCTGGGACCGCCCGCCGCACAATGTGGCTGGCGCCATGGACACGCTGGCGGCAGCCGTCACGGCCATGCTCGCCAACGGCCTTGCCGTGCCCGAGGCCGTGCGCGAAGCACAGGAGTATTTGCAGCAGGTGCTGGAAAATGCGTTCCGCCCCGGCATGGGACGCCATTTCCCCGACCGGTTCTTCTGGGCACGCAGCGAAGAGACCGATCAGGAAAGCGACGCCCCCGAAGCCTGAACCTCCGGCAGGAAATGCCGCAAAACAAAACGCCCGCGAGTATCGCGGGCGTTTTGCTTGGCTAGCGGGGGTTCAGCACGCCATCGGCGTGGCTACGACACGCGCGACTTGCCTCGCAGAGGCACCATGGCATCGTCGTCGGCATCGCCCTTCGGCCGTCCCCACACCTCGATCACTCGCTTGACGAACGGCGCCAGATCGTCGCCCTGCGCTCGCAACATGCGCACGAGTGCCGCGTACTGCCCCGGGAAGATCGCCGAGTTGTAGTTCTTCAGACGGCGAATGTCTTCCAGTGCCTCGTCGTCGCGTCCGGCGATCGCCAGCAGCACGATGTAGCGTTTGATCATCGTCGGCCCTGCACCCAGCGCCAGCGCCTCGCGATGCGCTGCCAGCTTCTCGTCGAGTTGATCCCGGCTCAGGAGCAAGGCGCCCGTGACCGCGTAATCGCCGTAAGGCGCAAAGAAGAGTGCCGGATCAGTGCGGTACGTGTCGATCTTGCCACTCCGATACGCCACCTCGACCCGTTGGTAGTCCTGGAAGAGCCAGGGAATCGCCACGCACGCAAACAACAGGATCACGCCATGGATGGCGCCGGTCGCCGTCGACGAAACGCTGTCGATCTGCTTCGTCTCGCAAAAACCCAGCAGGAACAATGCAGGCAGCAGGAAGAACGCGTAGTGCTGCGGATACTCGAGCATGGCATGGATGGCGAGCATGCCGAGCAGAACGAACGCGAGCGCGATCGGCGGCGCCTTGATGCCGCGCACAGCGCGCACGAACCAGAACGCCAGCGGCACCAGTACCGCCAACGTGCCGATAATGCCGGTCTTCGCGAGCAGGTCGATCAACACGTTGTGGGCGTTGTCTGCCATTTCGACCGGGCCGAGCTTGTCGACGAGAGCAAACTGAGCGTCGATGTAGTTCGACCAACCCGCCCCAAGCCACCAGTGCCCACGGAAGATCGCCAGACCGTACTCCCACAGGTTCAGTCGCCCCGTCACCTGACCGGCCTGCTGCATGCGGGCCACAGCGCTGCCGTCGAGTTGCAATCCCCAGGCCACGTTCGCCCAGCCGACGAACATCGTCACCAGGGCGAGCAACGGCAGGATCGCCACCGGCACGAACCATCGCATCGACCGGCGCATGTTGCGTGTCGGCTCGGCACGCTCCATCCACACGAGCCACAATCCCGATGCCGACAGCAACGCCAGTTGCAGCCACGGCGTGCGCGACCCGGTCAGGCAGATGCCGATGTCGAACGCGGCGCATGCGATCAGCCAGAGCCACGCGGGTAGCTTGCGGAGATACCAGAGATAGAAGGCCCCTGCGCTGGCGAGCGACAAATACGTCGCCAGATGATTCGGCTGGTACATATTGCCGAACAGTCGCCTGGCCACCGTCACGGTGTACCTGGCCACCAGCCAGGGCACGTTGCCTTCCAGATGAAACGCCTGCACGACCTGCGCACCCACTGCATACAGTCCTCCCAGCGTGAGCGCCACCGCGCTCCATCGCATGAGGGCATTGCGCCAGCCAAGTTGTGCGAGCCAGAACCCTGCATTCACTGCCACGATCATGGCCACGCCATAGAGCAGCGCCGTCATCATCAGTTGCGGCAGCTCGGTCGGCATGACCGCTCGCTGCACCAGGATGACCGCCACGAACGCAAGCGGCATCCAGGTAACGCGCGGCATGCGCAGCACCCGCCCATCGCGCTGCCACACGGCAATCATCGCGAGCAGGCCGAGCACACCAAAGAGCGAAAACGTCAGCGCTTCCGAGTAGAACGTGGAAATCGGGTAGGTGTGCTTGACGAGGTTATAGGGCAACGCCCAGATCAAGGCTACCGTGAGCCCGATCAACGAAAGAAGCAGAGGAGGAAACAAGATCGCCGCCGTGCAGTGCACCGGTTGGAAGATGCGCAAGCATAACGAAAAATGGCCGCCCGAGGGCAGCCATTTCATGCCTGACGCACGTCAATACGCCGTCATGGAATCCGTCATCGCGGCAGATCGCGGTGCGTGACGATGTGCGACATGTCACGACCGTCCGCGAACGGGATTCAGGCCGCCTTGGCCAGCGGGCCGCGACACTCCTGCGGCGCCAGCTTACCCGGCAAAGTCGCCCCGTTCGGCGCCCCTTCACGGCCCTGGGCGTAACACGTCCACACGATCTGGCCTTCCGGTGCCTTGCCGACCGTCAGCGCCTTGGGCGCACCATCGACGCCGGCACTCGTCGGCACCAGCACGAGCGCACCATCGCCCGCGCGTTGCGTGTAGGCGACGGTCACGTTGCCACTCACCGAGTCGATGCTCACCGAGTTCACGTTATCGGTCGCGCTCGGCGCCTGCCAGCCGCTGTTGAACGGCGCGCCATGCATGGCGTTCTCACTCACGAGTGCCTTGGCCGAGGCAGCAACGCCCAACCCTTCGACAACGCGTGCGCGCACCAGATAATTCTGCAGATACGGAACCCCTGCCGTGACCAACACGCCAATGATCGCCAGCACGATCATCAGCTCGATCAGGGTAAAACCCCGGGATTTGGCGATACCGGTGGTCCGGTGGCCGAAACGACGCATTGTGTAACTCCCTGCGAAAGCAATAAAAACAAAAGGGACATCGGGGGGAAGTGGGCGGAGTATGCCACAGCCCCAACGGCGAGCACCCTGCCGTAGATCAAAATCGGGCGGAGCCGTACAGGTGGAGAGAATCGTCCTAATCCAGGGCAGGACGATTCGTCCGATCGAGGGAGTGATTCCCCCGAAAAGTCACCATCGACCGAGAACCATGATCCCGGCAATGGACTCGATTATTCCGAAGAGGTTGCACGCAATTGACGTGCCTCGCTGCGTCGCTTGAGGATGAGCCCTACCACCACGACCAGCACAGCACCGATGGCGCACGCCACGTAATGTGTGTATTCGGCGGCCGCCCCCGGCAAATGCAGCAGGTGCCCGATGCCCGGGTCCGAGACGATCAGACCGCCCGCGATCCAGCCGAGCAGCGCCGCACCGGCGATGATGATGAACGGAAACCGGTCGAGGGCCTTGAGCACCAGTTGCGAGCCCCAGACGATGAGCGGAATGCTCACGAGCAGACCGAAGATCACGAGCGGCAATTGATGATGATCGGCGGCACTTTCTGCCGCACCGGCAATCGCGATCACGTTATCGATGCTCATCACCAGATCGGCCACGATGATGGTCTTGATGGCAGTCCAGAGCTTGTCGGCCGGCTTCACACTGTCGTGAGCGTCATGGTCGGGCACCAGCAGCTTGGTCCCGATCCAGAGCAACAACAAGCCCCCGAGCGCCTTAAGGTACGGCACCGCGAGCAGCGTCACGGCGAACGCGATCAGGATCACGCGCAACACGATGGCGCCAACCGTCCCCCACATGATTCCCTGCAACCGTTGCTTGGCCGGCAGGTTGCGGCAGGCCAGCGCGATCACCACGGCATTGTCGCCACCCAACAGGATGTCGATCATGATGATCTGCAGGACCGCGGCCCAGTTCAGCTCGGCAAAAAACGCAAGCATAGCGGGAATATCCTCGGGAACGAATGAAGCGAATGACTTGGGAATTGCAATAGCAAAAAAGGGAGCCCGATGTTCCGGGCTCCCTTTTCCTGACCGATTACACGCTCGCCGGTTCCGACGGCCGTGATGCGGTCATCCGGCGGGAATTACAGCGCAGCCTTGAGCAGGCGGCCCATTTCCGACGGATTACGGGTCACCTTGATACCGCAGGCGTCCATGATGGCCAGCTTGGCTTCGGCCGTGTCGGCACCGCCCGAGATCAGCGCGCCGGCGTGGCCCATGCGCTTGCCCGGGGGCGCCGTCACACCGGCGATGAAGCCGACGACCGGCTTCTTCATGTTGCCCTTGATCCACTCGGCGGCCGTCGCTTCGTCCGGACCACCGATTTCACCGATCATGATCACGGCGTCCGTATCCGGATCGTCGTTGAACATCTTCATGACGTCGATGTGCTTCAGACCGTTGATCGGGTCGCCACCGATACCGACGGCGGTCGACTGGCCCAGACCCAGGGCGGTCAGTTGACCCACGGCTTCGTACGTCAGGGTGCCCGAGCGCGAGACCACGCCGATGCGACCCTTCTTGTGGATGTGACCCGGCATGATGCCGATCTTCAGTTCGTCCGGCGTGATCACGCCCGGGCAATTCGGGCCGAGCAGCAGGGTCTTGCGACCTTCGCGACGCATACGGTCCTTCACTTCGATCATGTCACGAACGGGGATACCTTCCGTGATACAGATCGCCAGATCCAGGTCGGCTTCAACAGCTTCCCAGATCGCGGCAGCCGCGCCTGCGGGCGGCACGTAGATCACCGACACGGTCGCGCCGGTCTGTGCCTTCGCGTCCTTGACCGAACCGAAAATGGGAATGCCCTCGAAGTCTTCGCCAGCCTTCTTCGGGTTCACGCCAGCGACGAACGCGTTCTTGCCGTTCGCGTATTCGCGGCACATGCGGGTATGGAACTGGCCGGTTTTGCCAGTAATACCCTGGGTGATGACCTTGGTATCTTTGTTGATCAGAATCGACATTGCTTGATTTCCTTCATCCGGTTGCCGGGCAGCATTCGCGCAACCCCTCGGGGCGGCGCGCCGCTGCGGCTTCGACTGTTCTGGTTACTTGCCTGCGGCAGCCGCGACAACCTTCTGGGCAGCTTCTTCCATGCTGTCCGCAGAGATGATCGGCAGGCCGGATTCGGCGAGCATCTTCTTGCCCAGGTCCTCGTTCGTGCCCTTCATGCGCACGACCAGCGGCACCTTCAGCGAGACGGCCTTCGATGCTGCGATCACGCCTTCGGCGATCACATCGCAACGCATGATGCCGCCGAAGATGTTGACCAGAATGGCGGTCAGGTTCGGGTTCTTCAGCATGATCTTGAACGCTTCCGTGACCTTCTCGGTCGTGGCGCCACCGCCCACGTCCAGGAAGTTCGCAGGTTCGCCGCCGAACAGCTTGATGGTGTCCATCGTGGCCATGGCCAGACCGGCACCGTTCACCAGACAGCCGATGTTGCCGTCGAGCGAGATGTAAGCCAGATCGAACTTCGAGGCTTCGACTTCCGCCGGATCTTCTTCGTCCAGGTCGCGGTACGCGACGATTTCCGGGTGACGGAACAGGGCGTTCGAATCGAAGTTGAACTTGGCGTCCAGGGCGGTGACCGTGCCGTTGCTGCTCACGTTCAGCGGGTTGATTTCCGCCAGCGAAGCGTCCGTTTCCCAGAAGGCCTTGTACAGACCTTGCAGGATCGTGCGGGCTTGCGGAATCGAAGCGTCGGGAACGCTGATCTTCTTGGCCAGGTCGTCAGCTTGCGCATCGGTCAGACCGACCGACGGATCGATGACAACGTGGTGGATCAGTTCCGGATGCTTTTCAGCAACTTCTTCGATGTCCATGCCGCCTTCGCTCGAACCCATCATCACGATCTTCTGCGTGACGCGGTCAACCACCAGGCTGACGTACAGTTCGTTCTTGATGTCGGCGCCTTCTTCGATCAGCAGGCGATTGACCTTCTGGCCTTCCGGACCGGTCTGGTGCGTGACCAGTTGCATGCCGAGGATCTGGCCGGCGTATTCGCGCACTTGCTCGATCGACTTGGCAACCTTCACGCCGCCGCCCTTACCGCGACCGCCTGCGTGAATCTGGGCCTTGACCACCCAAACCGGACCGCCGAGTTCTTCGGCTGCCTTCACGGCCTCGTCCACGGAAAACGCCGGAATGCCGCGGGGCACCGCGACTCCGAATTTTCGGAGGATTTCCTTGCCTTGATACTCATGAATCTTCATGCGTGATTCCCTTCTTGCTGAGTTGGAAGTTTGGGTTCGAGCTTGCGAGTCGAGGCACCATCGCGCACCGCTTCTGTTGTGACGGGCGTCGTGGGCTCGTTCGCTCGATCGTTTGCGCGGCCGTTGAACCAGCGCGGGTAAAACCGGCGCACTGCCTCGCCATCAAACCGCAAGGCGTGACAATGTCCGAGTTGGAAAGGAGGCGCCGAACTCTCGGCATCGTTGGCGGCCTTGAGCGCCGTATCGGGGGTATGAATCACCACGCCGGCAAAGGCCTGAATCGCTGCCGTTGGCAGGACACTGCAAAGTTCTGTCAGATGGGTACAACCCGCCGCGCCGCCAAGGCGCTCGCGAACCGCGTGCCGGAAGCCGCGTCGCAGGTTAAGTCCGATCAACTGACGGTATTCGGGGCCGATCTGATCGCAAATGCCGGGATACGGCACCCAGTCCGAGACGGCCTCGGCGTCATGCACCTCGAAGTCCTCATCGATGGTCAGACGCAGCCAAAGCTCGTGAATCGGCGTGCCCTCCTTGCGAAGTCCCGTCGCCAATGCAAAATCCCGATCTTTGTGATCGGTTAGACGGGCTTCGATGTCCCATAGGCCATCCTCGCGCGAATACGCTTCGACAGCGATCGTGCGGCGGTGACGCAAGGTACGAGAGGCAGGCTCAGAGAGCGGCATGCGAGAGTGTGCAATGCATGAACGCAGAAAGATCTTGATTCTAGCATAGGCCACGGCGCACTCTGCCGCAGCGCAACAGAAGCCCGCCGCATAAGGCCGAATAACCCGACCCGGCGGTCGGGTTATCAAAATCACGAGATGGACTGGCGCATGGTGCGACGCCATATCGCGATAACTGTGGCATGACGCGTCACGCGAGATTCATCGTCATGTCACGCCAGCATCCATGCGGCCTGCCAGACGGTGGCGGTCATTGACGCGTTACCGATGAATGCACGCACATCTATCAGGAAAGCGACGCAACGCGCGTTAACAATCGTCCGAAAACTCGTCTGCACCGCGCACGATTTTGCTGATAACGGTACGTGAAAAACCGCGTGAGGCGAGAAAGCGCATCTGCTTGGCTCGAGCTTCGGGCGTGGTAGCGACCTCGCCGAACTTCTTTTGCCATACGACGCGGGCGCGTGCCAGTTCCGTACCGCGCAACTGCTCCGAGAGCACAGCGACCGTCTCGGCGTCGACCTGATGTTGTTTGAGTTCGTTGACGATACGTGTCGTGCCCAGGCGCGATGCGCGCCGGTTCACCACACTTTCCGCAAACCGTTCGTTGGACAGCCAGCGTTCCTGCTCGAGGCTGTCGAGCACACGATCGAGCGCTTCGGGATCCTCGGCATCGGCGAACGGCACGAGTTTGCGGCGCAGCTCCGTCCGGCTGTACTCGCGACGGGCCAGATACGACAGTGCCCGCGCCTTGAGGCTGAGCACGGGTTTTCGTGATCGCTTGACCGAAACGGCCTCGTCACCCGGTGGGGGCGGCGGTGCGTTCGGATCTCGGGGAGGACGGCGATTGATCATGACGTCATCGTGGCGCAATCGGACTGGACTAGAAAAACAAAAACGGCAACGCGATGCCATGTGGCCTCGCGTTGCCGTTCCGAAACGGGGCTTATCAGGCCTCGTCTTCTTCTTCGATCTCGCCGGTTTCGTTGATCGCCGTCACGCCGAGCGATGCACGCACCTTGTTTTCGATGTCGTGGGCAATCTCCGGATTTTCGCGCAGGAATTCACGCGCGTTGTCCTTACCCTGACCGATCTTCTCGCCGTTGTAGCTGTACCAGGCGCCGGCCTTCTCGACGATCTTGGCGTTCACGCCCAGATCGATGATTTCGCCTTCGCGCGAGATTCCCTGGCCGTAAAGGATGTCGAAGATGGCTTCGCGGAACGGCGGCGACACCTTGTTCTTGACGACCTTGACGCGGGTTTCGTTACCGACAACCTCGTCGCCCTTCTTGATCGAGCCGATACGGCGAATGTCCAGACGCACCGACGAGTAGAACTTCAGCGCGTTACCGCCCGTCGTGGTTTCCGGGTTACCGAACATCACACCGATCTTCATACGAATCTGGTTGATGAAGATCACCGTGCAGTTCGTGCGCTTGATGGTGCCGGTCAGCTTACGCAGGGCCTGAGACATCAGACGCGCTTGCAGACCCGGCAGCGAATCACCCATCTCG 3 | -------------------------------------------------------------------------------- /src/proc/cwdtw.cpp: -------------------------------------------------------------------------------- 1 | #include "cwdtw.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace std; 10 | 11 | //--------------- continuous wavelet transform (CWT) analysis -----------------// 12 | /** @scale0: level0 pyramind scale; @dscale: scale_i = scale0*(2^{i*dsacle} ); @npyr: total number of pyramind*/ 13 | void g::cwdtw::CWTAnalysis( 14 | const std::vector& raw, 15 | std::vector >& output, 16 | double scale0, double dscale, long npyr) 17 | { 18 | const double* sigs = &raw[0]; //sst_nino3.dat 19 | cwt_object wt; 20 | 21 | long N = raw.size(); 22 | double dt = 1;//2; //sample rate > maybe we should use 2? 23 | 24 | wt = cwt_init("dog", 2.0, N, dt, npyr); //"morlet", "dog", "paul" 25 | setCWTScales(wt, scale0, dscale, "pow", 2.0); 26 | cwt(wt, sigs); 27 | 28 | output.resize(npyr); 29 | for(long k = npyr; k--;){ 30 | long idx = npyr-k-1; 31 | output[idx].resize(raw.size()); 32 | long offset = k*raw.size(); 33 | for(long i = 0; i < output[idx].size(); i++){ 34 | output[idx][i] = wt->output[i+offset].re; 35 | } 36 | } 37 | 38 | cwt_free(wt); 39 | } 40 | 41 | //----------------- boundary generation for constrained dynamic time warping (cDTW) -------------// 42 | void g::cwdtw::BoundGeneration( 43 | std::vector >& cosali, 44 | long neib, std::vector >& bound, int mode, 45 | int RENMIN_or_SHENG) 46 | { 47 | 48 | //if(mode!=-1) //-> mode = -1 means Renmin mode 49 | vector > cosali_=cosali; 50 | if(mode==1) //-> use partial-diagonol alignment 51 | { 52 | 53 | //-------- generate partial-diagonol alignment -------// 54 | vector > cosali2; 55 | cosali2.push_back(cosali[0]); 56 | for(long i = 1; i < cosali.size(); i++){ 57 | if(cosali[i].first != cosali2[cosali2.size()-1].first){ 58 | cosali2.push_back(cosali[i]); 59 | } 60 | else{ 61 | cosali2[cosali2.size()-1].second = cosali[i].second; 62 | } 63 | } 64 | 65 | cosali_.clear(); 66 | for(long i = 1; i < cosali2.size(); i++) 67 | { 68 | long pre_idx = cosali2[i-1].first, cur_idx = cosali2[i].first; 69 | long pre_anchor = cosali2[i-1].second, cur_anchor = cosali2[i].second; 70 | double anchor_diff = (cur_anchor-pre_anchor)/(cur_idx-pre_idx); 71 | for(long k = pre_idx, count = 0; k < cur_idx; k++, count++) 72 | { 73 | long mid = pre_anchor+(long)(count*anchor_diff); //assign point relationship 74 | if(midcur_anchor)mid=cur_anchor; 76 | cosali_.push_back(make_pair(k,mid)); 77 | } 78 | } 79 | cosali_.push_back(cosali2[cosali2.size()-1]); 80 | } 81 | 82 | //----> output pre-bound alignnment ------- 83 | // { 84 | // for(int i = 0; i < cosali_.size(); i++) 85 | // { 86 | // printf("%d -> %d %d \n",i,cosali_[i].first,cosali_[i].second); 87 | // } 88 | // } 89 | 90 | 91 | //---------- use block bound ------------//start 92 | //-> get signal length 93 | long moln1=cosali_[cosali_.size()-1].first+1; 94 | long moln2=cosali_[cosali_.size()-1].second+1; 95 | //-> renmin align to sheng style 96 | std::vector > align_sheng; 97 | g::proc::Renmin_To_Sheng_align(moln1,moln2,cosali_,align_sheng); 98 | //-> get bound in sheng style 99 | std::vector > bound_sheng; 100 | g::proc::From_Align_Get_Bound(moln1,moln2,align_sheng,bound_sheng,neib); 101 | //-> transfer bound to renmin style 102 | g::proc::Sheng_To_Renmin_bound(moln1,moln2,bound_sheng,bound); 103 | //----- maybe useful -----// 104 | bound[0].first = 0; 105 | bound[bound.size()-1].first = bound[bound.size()-2].first; 106 | bound[bound.size()-1].second = cosali[cosali.size()-1].second; 107 | 108 | 109 | if(RENMIN_or_SHENG==1) //-> use Sheng's bound definition 110 | { 111 | bound=bound_sheng; 112 | } 113 | 114 | //----> output post-bound alignnment ------- 115 | // { 116 | // for(int i = 0; i < bound.size(); i++) 117 | // { 118 | // printf("%d -> %d %d \n",i,bound[i].first,bound[i].second); 119 | // } 120 | // exit(-1); 121 | // } 122 | 123 | return; 124 | //---------- use block bound ------------//over 125 | 126 | /* 127 | int radius=neib1; 128 | std::vector > cosali2; 129 | 130 | cosali2.push_back(cosali[0]); 131 | for(int i = 1; i < cosali.size(); i++){ 132 | if(cosali[i].first != cosali2[cosali2.size()-1].first){ 133 | cosali2.push_back(cosali[i]); 134 | } 135 | else{ 136 | cosali2[cosali2.size()-1].second = cosali[i].second; 137 | } 138 | } 139 | 140 | cosali = cosali2; 141 | 142 | bound.resize(cosali[cosali.size()-1].first+1); 143 | bound.assign(cosali[cosali.size()-1].first+1, std::make_pair(-1,-1)); 144 | 145 | for(int i = 1; i < cosali.size(); i++){ 146 | int pre_idx = cosali[i-1].first, cur_idx = cosali[i].first; 147 | int pre_anchor = cosali[i-1].second, cur_anchor = cosali[i].second; 148 | 149 | double anchor_diff; 150 | 151 | anchor_diff = (cur_anchor-pre_anchor)/(cur_idx-pre_idx); 152 | 153 | int neighbor = int(anchor_diff+0.5)+radius; 154 | 155 | for(int i = pre_idx, count = 0; i < cur_idx; i++, count++){ 156 | int mid = pre_anchor+std::round(count*anchor_diff); //assign point relationship 157 | bound[i].first = mid-neighbor < 0 ? 0 : mid-neighbor; 158 | bound[i].second = mid+neighbor > cosali[cosali.size()-1].second ? cosali[cosali.size()-1].second : mid+neighbor; 159 | } 160 | } 161 | 162 | // for(int i = 0; i < bound.size(); i++){ 163 | // std::cout<& in1, std::vector& in2, 175 | std::vector >& alignment, 176 | long radius, long max_level, int mode, 177 | double* totaldiff) 178 | { 179 | double tdiff; 180 | vector > > sig1peaks, sig2peaks; 181 | long length1 = in1.size(), length2 = in2.size(); 182 | 183 | //---- determine level -------// 184 | long l1=1; 185 | for(;;) 186 | { 187 | long num1=pow(2,l1); 188 | if(length1/num1max_level)level=max_level; 200 | 201 | //---- create sigpeak ------// 202 | long cur_level=1; 203 | for(long k=level;k>=0;k--) 204 | { 205 | vector > sig1peaks_cur; 206 | vector > sig2peaks_cur; 207 | 208 | //------ using Equally Averaging ------//(just for comparison) 209 | //--> proc peak1 210 | long cur1=0; 211 | long num1=pow(2,cur_level); 212 | for(long i = 0; i < length1/num1 -1; i++) 213 | { 214 | double val=0; 215 | for(long j=0;j proc peak2 236 | long cur2=0; 237 | long num2=pow(2,cur_level); 238 | for(long i = 0; i < length2/num2 -1; i++) 239 | { 240 | double val=0; 241 | for(long j=0;j peak1(sig1peaks[k].size()); 273 | vector peak2(sig2peaks[k].size()); 274 | for(long i = sig1peaks[k].size(); i--;){ 275 | peak1[i] = sig1peaks[k][i].second; 276 | } 277 | for(long i = sig2peaks[k].size(); i--;){ 278 | peak2[i] = sig2peaks[k][i].second; 279 | } 280 | 281 | //--- perform align ----// 282 | //----- apply DTW or cDTW dependent on k-th level -------// 283 | if(k == 0){ 284 | tdiff = g::proc::DynamicTimeWarping(peak1, peak2, alignment); 285 | } 286 | else{ 287 | //----- ReMapIndex_partI (map ground level upon k-th level) -----// 288 | long c = 0; 289 | for(long i = 0; i < alignment.size(); i++){ 290 | while(sig1peaks[k][c].first < alignment[i].first){ 291 | c++; 292 | } 293 | alignment[i].first = c; 294 | } 295 | 296 | long d = 0; 297 | for(long i = 0; i < alignment.size(); i++){ 298 | while(sig2peaks[k][d].first < alignment[i].second){ 299 | d++; 300 | } 301 | alignment[i].second = d; 302 | } 303 | //----- cDWT (constrained DWT) -------// 304 | vector > bound; 305 | BoundGeneration(alignment, radius, bound, mode); 306 | tdiff = g::proc::BoundDynamicTimeWarping(peak1, peak2, bound, alignment); 307 | } 308 | //----- ReMapIndex_partII (map k-th level back to ground level) -----// 309 | for(long i = alignment.size(); i--;){ 310 | alignment[i].first = sig1peaks[k][alignment[i].first].first; 311 | alignment[i].second = sig2peaks[k][alignment[i].second].first; 312 | } 313 | } 314 | 315 | //----- return diff ------// 316 | if(totaldiff){ 317 | *totaldiff = tdiff; 318 | } 319 | } 320 | 321 | 322 | //====================== continous wavelet dynamic time warping (cwDTW) ========================// 323 | void g::cwdtw::MultiLevel_WaveletDTW( 324 | std::vector& in1, std::vector& in2, 325 | std::vector >& sig1, 326 | std::vector >& sig2, 327 | std::vector >& alignment, 328 | long radius, int test, int mode, 329 | double* totaldiff) 330 | { 331 | double tdiff; 332 | std::vector > sig1peaks, sig2peaks; 333 | double length1 = sig1[0].size(), length2 = sig2[0].size(); 334 | 335 | long tot_size=sig1.size(); 336 | for(long k = 0; k < tot_size; k++) 337 | { 338 | //------ peakpick CWT signal -------------// 339 | g::proc::PeakPick(sig1[k], sig1peaks); 340 | g::proc::PeakPick(sig2[k], sig2peaks); 341 | // std::cout< peak1(sig1peaks.size()); 343 | std::vector peak2(sig2peaks.size()); 344 | 345 | 346 | //-------- use peak picking result ---------// 347 | for(long i = sig1peaks.size(); i--;){ 348 | peak1[i] = sig1peaks[i].second; 349 | } 350 | for(long i = sig2peaks.size(); i--;){ 351 | peak2[i] = sig2peaks[i].second; 352 | } 353 | 354 | 355 | //================================ peak average =====================//start 356 | if(test==2) //-> peak_ave 357 | { 358 | //-------- use peak average reso --------------//(just for comparison) 359 | for(long i = 1; i < sig1peaks.size()-1; i++) 360 | { 361 | long start=(sig1peaks[i-1].first+sig1peaks[i].first)/2; 362 | long end=(sig1peaks[i].first+sig1peaks[i+1].first)/2; 363 | double val=0; 364 | long cc; 365 | for(long j=start;j<=end;j++) 366 | { 367 | val+=in1[j]; 368 | cc++; 369 | } 370 | peak1[i]=val; 371 | } 372 | for(long i = 1; i < sig2peaks.size()-1; i++) 373 | { 374 | long start=(sig2peaks[i-1].first+sig2peaks[i].first)/2; 375 | long end=(sig2peaks[i].first+sig2peaks[i+1].first)/2; 376 | double val=0; 377 | long cc; 378 | for(long j=start;j<=end;j++) 379 | { 380 | val+=in2[j]; 381 | cc++; 382 | } 383 | peak2[i]=val; 384 | } 385 | } 386 | //================================ peak average =====================//over 387 | 388 | 389 | //================================ equal average =====================//start 390 | if(test==1) //-> equal_ave 391 | { 392 | //------ using Equally Averaging ------//(just for comparison) 393 | //--> proc peak1 394 | long cur1=0; 395 | long num1=(long)(1.0*in1.size()/sig1peaks.size() ); 396 | for(long i = 0; i < sig1peaks.size()-1; i++) 397 | { 398 | double val=0; 399 | for(long j=0;j proc peak2 426 | long cur2=0; 427 | long num2=(long)(1.0*in2.size()/sig2peaks.size() ); 428 | for(long i = 0; i < sig2peaks.size()-1; i++) 429 | { 430 | double val=0; 431 | for(long j=0;j > bound; 483 | long neib=radius*pow(2,tot_size-k); //adaptive radius 484 | BoundGeneration(alignment, neib, bound, mode); 485 | tdiff = g::proc::BoundDynamicTimeWarping(peak1, peak2, bound, alignment); 486 | } 487 | //----- ReMapIndex_partII (map k-th level back to ground level) -----// 488 | for(long i = alignment.size(); i--;){ 489 | alignment[i].first = sig1peaks[alignment[i].first].first; 490 | alignment[i].second = sig2peaks[alignment[i].second].first; 491 | } 492 | 493 | } 494 | 495 | if(totaldiff){ 496 | *totaldiff = tdiff; 497 | } 498 | } 499 | -------------------------------------------------------------------------------- /src/kmer/5mer_index_mapping: -------------------------------------------------------------------------------- 1 | AAAAA 0 2 | AAAAC 1 3 | AAAAG 2 4 | AAAAT 3 5 | AAACA 4 6 | AAACC 5 7 | AAACG 6 8 | AAACT 7 9 | AAAGA 8 10 | AAAGC 9 11 | AAAGG 10 12 | AAAGT 11 13 | AAATA 12 14 | AAATC 13 15 | AAATG 14 16 | AAATT 15 17 | AACAA 16 18 | AACAC 17 19 | AACAG 18 20 | AACAT 19 21 | AACCA 20 22 | AACCC 21 23 | AACCG 22 24 | AACCT 23 25 | AACGA 24 26 | AACGC 25 27 | AACGG 26 28 | AACGT 27 29 | AACTA 28 30 | AACTC 29 31 | AACTG 30 32 | AACTT 31 33 | AAGAA 32 34 | AAGAC 33 35 | AAGAG 34 36 | AAGAT 35 37 | AAGCA 36 38 | AAGCC 37 39 | AAGCG 38 40 | AAGCT 39 41 | AAGGA 40 42 | AAGGC 41 43 | AAGGG 42 44 | AAGGT 43 45 | AAGTA 44 46 | AAGTC 45 47 | AAGTG 46 48 | AAGTT 47 49 | AATAA 48 50 | AATAC 49 51 | AATAG 50 52 | AATAT 51 53 | AATCA 52 54 | AATCC 53 55 | AATCG 54 56 | AATCT 55 57 | AATGA 56 58 | AATGC 57 59 | AATGG 58 60 | AATGT 59 61 | AATTA 60 62 | AATTC 61 63 | AATTG 62 64 | AATTT 63 65 | ACAAA 64 66 | ACAAC 65 67 | ACAAG 66 68 | ACAAT 67 69 | ACACA 68 70 | ACACC 69 71 | ACACG 70 72 | ACACT 71 73 | ACAGA 72 74 | ACAGC 73 75 | ACAGG 74 76 | ACAGT 75 77 | ACATA 76 78 | ACATC 77 79 | ACATG 78 80 | ACATT 79 81 | ACCAA 80 82 | ACCAC 81 83 | ACCAG 82 84 | ACCAT 83 85 | ACCCA 84 86 | ACCCC 85 87 | ACCCG 86 88 | ACCCT 87 89 | ACCGA 88 90 | ACCGC 89 91 | ACCGG 90 92 | ACCGT 91 93 | ACCTA 92 94 | ACCTC 93 95 | ACCTG 94 96 | ACCTT 95 97 | ACGAA 96 98 | ACGAC 97 99 | ACGAG 98 100 | ACGAT 99 101 | ACGCA 100 102 | ACGCC 101 103 | ACGCG 102 104 | ACGCT 103 105 | ACGGA 104 106 | ACGGC 105 107 | ACGGG 106 108 | ACGGT 107 109 | ACGTA 108 110 | ACGTC 109 111 | ACGTG 110 112 | ACGTT 111 113 | ACTAA 112 114 | ACTAC 113 115 | ACTAG 114 116 | ACTAT 115 117 | ACTCA 116 118 | ACTCC 117 119 | ACTCG 118 120 | ACTCT 119 121 | ACTGA 120 122 | ACTGC 121 123 | ACTGG 122 124 | ACTGT 123 125 | ACTTA 124 126 | ACTTC 125 127 | ACTTG 126 128 | ACTTT 127 129 | AGAAA 128 130 | AGAAC 129 131 | AGAAG 130 132 | AGAAT 131 133 | AGACA 132 134 | AGACC 133 135 | AGACG 134 136 | AGACT 135 137 | AGAGA 136 138 | AGAGC 137 139 | AGAGG 138 140 | AGAGT 139 141 | AGATA 140 142 | AGATC 141 143 | AGATG 142 144 | AGATT 143 145 | AGCAA 144 146 | AGCAC 145 147 | AGCAG 146 148 | AGCAT 147 149 | AGCCA 148 150 | AGCCC 149 151 | AGCCG 150 152 | AGCCT 151 153 | AGCGA 152 154 | AGCGC 153 155 | AGCGG 154 156 | AGCGT 155 157 | AGCTA 156 158 | AGCTC 157 159 | AGCTG 158 160 | AGCTT 159 161 | AGGAA 160 162 | AGGAC 161 163 | AGGAG 162 164 | AGGAT 163 165 | AGGCA 164 166 | AGGCC 165 167 | AGGCG 166 168 | AGGCT 167 169 | AGGGA 168 170 | AGGGC 169 171 | AGGGG 170 172 | AGGGT 171 173 | AGGTA 172 174 | AGGTC 173 175 | AGGTG 174 176 | AGGTT 175 177 | AGTAA 176 178 | AGTAC 177 179 | AGTAG 178 180 | AGTAT 179 181 | AGTCA 180 182 | AGTCC 181 183 | AGTCG 182 184 | AGTCT 183 185 | AGTGA 184 186 | AGTGC 185 187 | AGTGG 186 188 | AGTGT 187 189 | AGTTA 188 190 | AGTTC 189 191 | AGTTG 190 192 | AGTTT 191 193 | ATAAA 192 194 | ATAAC 193 195 | ATAAG 194 196 | ATAAT 195 197 | ATACA 196 198 | ATACC 197 199 | ATACG 198 200 | ATACT 199 201 | ATAGA 200 202 | ATAGC 201 203 | ATAGG 202 204 | ATAGT 203 205 | ATATA 204 206 | ATATC 205 207 | ATATG 206 208 | ATATT 207 209 | ATCAA 208 210 | ATCAC 209 211 | ATCAG 210 212 | ATCAT 211 213 | ATCCA 212 214 | ATCCC 213 215 | ATCCG 214 216 | ATCCT 215 217 | ATCGA 216 218 | ATCGC 217 219 | ATCGG 218 220 | ATCGT 219 221 | ATCTA 220 222 | ATCTC 221 223 | ATCTG 222 224 | ATCTT 223 225 | ATGAA 224 226 | ATGAC 225 227 | ATGAG 226 228 | ATGAT 227 229 | ATGCA 228 230 | ATGCC 229 231 | ATGCG 230 232 | ATGCT 231 233 | ATGGA 232 234 | ATGGC 233 235 | ATGGG 234 236 | ATGGT 235 237 | ATGTA 236 238 | ATGTC 237 239 | ATGTG 238 240 | ATGTT 239 241 | ATTAA 240 242 | ATTAC 241 243 | ATTAG 242 244 | ATTAT 243 245 | ATTCA 244 246 | ATTCC 245 247 | ATTCG 246 248 | ATTCT 247 249 | ATTGA 248 250 | ATTGC 249 251 | ATTGG 250 252 | ATTGT 251 253 | ATTTA 252 254 | ATTTC 253 255 | ATTTG 254 256 | ATTTT 255 257 | CAAAA 256 258 | CAAAC 257 259 | CAAAG 258 260 | CAAAT 259 261 | CAACA 260 262 | CAACC 261 263 | CAACG 262 264 | CAACT 263 265 | CAAGA 264 266 | CAAGC 265 267 | CAAGG 266 268 | CAAGT 267 269 | CAATA 268 270 | CAATC 269 271 | CAATG 270 272 | CAATT 271 273 | CACAA 272 274 | CACAC 273 275 | CACAG 274 276 | CACAT 275 277 | CACCA 276 278 | CACCC 277 279 | CACCG 278 280 | CACCT 279 281 | CACGA 280 282 | CACGC 281 283 | CACGG 282 284 | CACGT 283 285 | CACTA 284 286 | CACTC 285 287 | CACTG 286 288 | CACTT 287 289 | CAGAA 288 290 | CAGAC 289 291 | CAGAG 290 292 | CAGAT 291 293 | CAGCA 292 294 | CAGCC 293 295 | CAGCG 294 296 | CAGCT 295 297 | CAGGA 296 298 | CAGGC 297 299 | CAGGG 298 300 | CAGGT 299 301 | CAGTA 300 302 | CAGTC 301 303 | CAGTG 302 304 | CAGTT 303 305 | CATAA 304 306 | CATAC 305 307 | CATAG 306 308 | CATAT 307 309 | CATCA 308 310 | CATCC 309 311 | CATCG 310 312 | CATCT 311 313 | CATGA 312 314 | CATGC 313 315 | CATGG 314 316 | CATGT 315 317 | CATTA 316 318 | CATTC 317 319 | CATTG 318 320 | CATTT 319 321 | CCAAA 320 322 | CCAAC 321 323 | CCAAG 322 324 | CCAAT 323 325 | CCACA 324 326 | CCACC 325 327 | CCACG 326 328 | CCACT 327 329 | CCAGA 328 330 | CCAGC 329 331 | CCAGG 330 332 | CCAGT 331 333 | CCATA 332 334 | CCATC 333 335 | CCATG 334 336 | CCATT 335 337 | CCCAA 336 338 | CCCAC 337 339 | CCCAG 338 340 | CCCAT 339 341 | CCCCA 340 342 | CCCCC 341 343 | CCCCG 342 344 | CCCCT 343 345 | CCCGA 344 346 | CCCGC 345 347 | CCCGG 346 348 | CCCGT 347 349 | CCCTA 348 350 | CCCTC 349 351 | CCCTG 350 352 | CCCTT 351 353 | CCGAA 352 354 | CCGAC 353 355 | CCGAG 354 356 | CCGAT 355 357 | CCGCA 356 358 | CCGCC 357 359 | CCGCG 358 360 | CCGCT 359 361 | CCGGA 360 362 | CCGGC 361 363 | CCGGG 362 364 | CCGGT 363 365 | CCGTA 364 366 | CCGTC 365 367 | CCGTG 366 368 | CCGTT 367 369 | CCTAA 368 370 | CCTAC 369 371 | CCTAG 370 372 | CCTAT 371 373 | CCTCA 372 374 | CCTCC 373 375 | CCTCG 374 376 | CCTCT 375 377 | CCTGA 376 378 | CCTGC 377 379 | CCTGG 378 380 | CCTGT 379 381 | CCTTA 380 382 | CCTTC 381 383 | CCTTG 382 384 | CCTTT 383 385 | CGAAA 384 386 | CGAAC 385 387 | CGAAG 386 388 | CGAAT 387 389 | CGACA 388 390 | CGACC 389 391 | CGACG 390 392 | CGACT 391 393 | CGAGA 392 394 | CGAGC 393 395 | CGAGG 394 396 | CGAGT 395 397 | CGATA 396 398 | CGATC 397 399 | CGATG 398 400 | CGATT 399 401 | CGCAA 400 402 | CGCAC 401 403 | CGCAG 402 404 | CGCAT 403 405 | CGCCA 404 406 | CGCCC 405 407 | CGCCG 406 408 | CGCCT 407 409 | CGCGA 408 410 | CGCGC 409 411 | CGCGG 410 412 | CGCGT 411 413 | CGCTA 412 414 | CGCTC 413 415 | CGCTG 414 416 | CGCTT 415 417 | CGGAA 416 418 | CGGAC 417 419 | CGGAG 418 420 | CGGAT 419 421 | CGGCA 420 422 | CGGCC 421 423 | CGGCG 422 424 | CGGCT 423 425 | CGGGA 424 426 | CGGGC 425 427 | CGGGG 426 428 | CGGGT 427 429 | CGGTA 428 430 | CGGTC 429 431 | CGGTG 430 432 | CGGTT 431 433 | CGTAA 432 434 | CGTAC 433 435 | CGTAG 434 436 | CGTAT 435 437 | CGTCA 436 438 | CGTCC 437 439 | CGTCG 438 440 | CGTCT 439 441 | CGTGA 440 442 | CGTGC 441 443 | CGTGG 442 444 | CGTGT 443 445 | CGTTA 444 446 | CGTTC 445 447 | CGTTG 446 448 | CGTTT 447 449 | CTAAA 448 450 | CTAAC 449 451 | CTAAG 450 452 | CTAAT 451 453 | CTACA 452 454 | CTACC 453 455 | CTACG 454 456 | CTACT 455 457 | CTAGA 456 458 | CTAGC 457 459 | CTAGG 458 460 | CTAGT 459 461 | CTATA 460 462 | CTATC 461 463 | CTATG 462 464 | CTATT 463 465 | CTCAA 464 466 | CTCAC 465 467 | CTCAG 466 468 | CTCAT 467 469 | CTCCA 468 470 | CTCCC 469 471 | CTCCG 470 472 | CTCCT 471 473 | CTCGA 472 474 | CTCGC 473 475 | CTCGG 474 476 | CTCGT 475 477 | CTCTA 476 478 | CTCTC 477 479 | CTCTG 478 480 | CTCTT 479 481 | CTGAA 480 482 | CTGAC 481 483 | CTGAG 482 484 | CTGAT 483 485 | CTGCA 484 486 | CTGCC 485 487 | CTGCG 486 488 | CTGCT 487 489 | CTGGA 488 490 | CTGGC 489 491 | CTGGG 490 492 | CTGGT 491 493 | CTGTA 492 494 | CTGTC 493 495 | CTGTG 494 496 | CTGTT 495 497 | CTTAA 496 498 | CTTAC 497 499 | CTTAG 498 500 | CTTAT 499 501 | CTTCA 500 502 | CTTCC 501 503 | CTTCG 502 504 | CTTCT 503 505 | CTTGA 504 506 | CTTGC 505 507 | CTTGG 506 508 | CTTGT 507 509 | CTTTA 508 510 | CTTTC 509 511 | CTTTG 510 512 | CTTTT 511 513 | GAAAA 512 514 | GAAAC 513 515 | GAAAG 514 516 | GAAAT 515 517 | GAACA 516 518 | GAACC 517 519 | GAACG 518 520 | GAACT 519 521 | GAAGA 520 522 | GAAGC 521 523 | GAAGG 522 524 | GAAGT 523 525 | GAATA 524 526 | GAATC 525 527 | GAATG 526 528 | GAATT 527 529 | GACAA 528 530 | GACAC 529 531 | GACAG 530 532 | GACAT 531 533 | GACCA 532 534 | GACCC 533 535 | GACCG 534 536 | GACCT 535 537 | GACGA 536 538 | GACGC 537 539 | GACGG 538 540 | GACGT 539 541 | GACTA 540 542 | GACTC 541 543 | GACTG 542 544 | GACTT 543 545 | GAGAA 544 546 | GAGAC 545 547 | GAGAG 546 548 | GAGAT 547 549 | GAGCA 548 550 | GAGCC 549 551 | GAGCG 550 552 | GAGCT 551 553 | GAGGA 552 554 | GAGGC 553 555 | GAGGG 554 556 | GAGGT 555 557 | GAGTA 556 558 | GAGTC 557 559 | GAGTG 558 560 | GAGTT 559 561 | GATAA 560 562 | GATAC 561 563 | GATAG 562 564 | GATAT 563 565 | GATCA 564 566 | GATCC 565 567 | GATCG 566 568 | GATCT 567 569 | GATGA 568 570 | GATGC 569 571 | GATGG 570 572 | GATGT 571 573 | GATTA 572 574 | GATTC 573 575 | GATTG 574 576 | GATTT 575 577 | GCAAA 576 578 | GCAAC 577 579 | GCAAG 578 580 | GCAAT 579 581 | GCACA 580 582 | GCACC 581 583 | GCACG 582 584 | GCACT 583 585 | GCAGA 584 586 | GCAGC 585 587 | GCAGG 586 588 | GCAGT 587 589 | GCATA 588 590 | GCATC 589 591 | GCATG 590 592 | GCATT 591 593 | GCCAA 592 594 | GCCAC 593 595 | GCCAG 594 596 | GCCAT 595 597 | GCCCA 596 598 | GCCCC 597 599 | GCCCG 598 600 | GCCCT 599 601 | GCCGA 600 602 | GCCGC 601 603 | GCCGG 602 604 | GCCGT 603 605 | GCCTA 604 606 | GCCTC 605 607 | GCCTG 606 608 | GCCTT 607 609 | GCGAA 608 610 | GCGAC 609 611 | GCGAG 610 612 | GCGAT 611 613 | GCGCA 612 614 | GCGCC 613 615 | GCGCG 614 616 | GCGCT 615 617 | GCGGA 616 618 | GCGGC 617 619 | GCGGG 618 620 | GCGGT 619 621 | GCGTA 620 622 | GCGTC 621 623 | GCGTG 622 624 | GCGTT 623 625 | GCTAA 624 626 | GCTAC 625 627 | GCTAG 626 628 | GCTAT 627 629 | GCTCA 628 630 | GCTCC 629 631 | GCTCG 630 632 | GCTCT 631 633 | GCTGA 632 634 | GCTGC 633 635 | GCTGG 634 636 | GCTGT 635 637 | GCTTA 636 638 | GCTTC 637 639 | GCTTG 638 640 | GCTTT 639 641 | GGAAA 640 642 | GGAAC 641 643 | GGAAG 642 644 | GGAAT 643 645 | GGACA 644 646 | GGACC 645 647 | GGACG 646 648 | GGACT 647 649 | GGAGA 648 650 | GGAGC 649 651 | GGAGG 650 652 | GGAGT 651 653 | GGATA 652 654 | GGATC 653 655 | GGATG 654 656 | GGATT 655 657 | GGCAA 656 658 | GGCAC 657 659 | GGCAG 658 660 | GGCAT 659 661 | GGCCA 660 662 | GGCCC 661 663 | GGCCG 662 664 | GGCCT 663 665 | GGCGA 664 666 | GGCGC 665 667 | GGCGG 666 668 | GGCGT 667 669 | GGCTA 668 670 | GGCTC 669 671 | GGCTG 670 672 | GGCTT 671 673 | GGGAA 672 674 | GGGAC 673 675 | GGGAG 674 676 | GGGAT 675 677 | GGGCA 676 678 | GGGCC 677 679 | GGGCG 678 680 | GGGCT 679 681 | GGGGA 680 682 | GGGGC 681 683 | GGGGG 682 684 | GGGGT 683 685 | GGGTA 684 686 | GGGTC 685 687 | GGGTG 686 688 | GGGTT 687 689 | GGTAA 688 690 | GGTAC 689 691 | GGTAG 690 692 | GGTAT 691 693 | GGTCA 692 694 | GGTCC 693 695 | GGTCG 694 696 | GGTCT 695 697 | GGTGA 696 698 | GGTGC 697 699 | GGTGG 698 700 | GGTGT 699 701 | GGTTA 700 702 | GGTTC 701 703 | GGTTG 702 704 | GGTTT 703 705 | GTAAA 704 706 | GTAAC 705 707 | GTAAG 706 708 | GTAAT 707 709 | GTACA 708 710 | GTACC 709 711 | GTACG 710 712 | GTACT 711 713 | GTAGA 712 714 | GTAGC 713 715 | GTAGG 714 716 | GTAGT 715 717 | GTATA 716 718 | GTATC 717 719 | GTATG 718 720 | GTATT 719 721 | GTCAA 720 722 | GTCAC 721 723 | GTCAG 722 724 | GTCAT 723 725 | GTCCA 724 726 | GTCCC 725 727 | GTCCG 726 728 | GTCCT 727 729 | GTCGA 728 730 | GTCGC 729 731 | GTCGG 730 732 | GTCGT 731 733 | GTCTA 732 734 | GTCTC 733 735 | GTCTG 734 736 | GTCTT 735 737 | GTGAA 736 738 | GTGAC 737 739 | GTGAG 738 740 | GTGAT 739 741 | GTGCA 740 742 | GTGCC 741 743 | GTGCG 742 744 | GTGCT 743 745 | GTGGA 744 746 | GTGGC 745 747 | GTGGG 746 748 | GTGGT 747 749 | GTGTA 748 750 | GTGTC 749 751 | GTGTG 750 752 | GTGTT 751 753 | GTTAA 752 754 | GTTAC 753 755 | GTTAG 754 756 | GTTAT 755 757 | GTTCA 756 758 | GTTCC 757 759 | GTTCG 758 760 | GTTCT 759 761 | GTTGA 760 762 | GTTGC 761 763 | GTTGG 762 764 | GTTGT 763 765 | GTTTA 764 766 | GTTTC 765 767 | GTTTG 766 768 | GTTTT 767 769 | TAAAA 768 770 | TAAAC 769 771 | TAAAG 770 772 | TAAAT 771 773 | TAACA 772 774 | TAACC 773 775 | TAACG 774 776 | TAACT 775 777 | TAAGA 776 778 | TAAGC 777 779 | TAAGG 778 780 | TAAGT 779 781 | TAATA 780 782 | TAATC 781 783 | TAATG 782 784 | TAATT 783 785 | TACAA 784 786 | TACAC 785 787 | TACAG 786 788 | TACAT 787 789 | TACCA 788 790 | TACCC 789 791 | TACCG 790 792 | TACCT 791 793 | TACGA 792 794 | TACGC 793 795 | TACGG 794 796 | TACGT 795 797 | TACTA 796 798 | TACTC 797 799 | TACTG 798 800 | TACTT 799 801 | TAGAA 800 802 | TAGAC 801 803 | TAGAG 802 804 | TAGAT 803 805 | TAGCA 804 806 | TAGCC 805 807 | TAGCG 806 808 | TAGCT 807 809 | TAGGA 808 810 | TAGGC 809 811 | TAGGG 810 812 | TAGGT 811 813 | TAGTA 812 814 | TAGTC 813 815 | TAGTG 814 816 | TAGTT 815 817 | TATAA 816 818 | TATAC 817 819 | TATAG 818 820 | TATAT 819 821 | TATCA 820 822 | TATCC 821 823 | TATCG 822 824 | TATCT 823 825 | TATGA 824 826 | TATGC 825 827 | TATGG 826 828 | TATGT 827 829 | TATTA 828 830 | TATTC 829 831 | TATTG 830 832 | TATTT 831 833 | TCAAA 832 834 | TCAAC 833 835 | TCAAG 834 836 | TCAAT 835 837 | TCACA 836 838 | TCACC 837 839 | TCACG 838 840 | TCACT 839 841 | TCAGA 840 842 | TCAGC 841 843 | TCAGG 842 844 | TCAGT 843 845 | TCATA 844 846 | TCATC 845 847 | TCATG 846 848 | TCATT 847 849 | TCCAA 848 850 | TCCAC 849 851 | TCCAG 850 852 | TCCAT 851 853 | TCCCA 852 854 | TCCCC 853 855 | TCCCG 854 856 | TCCCT 855 857 | TCCGA 856 858 | TCCGC 857 859 | TCCGG 858 860 | TCCGT 859 861 | TCCTA 860 862 | TCCTC 861 863 | TCCTG 862 864 | TCCTT 863 865 | TCGAA 864 866 | TCGAC 865 867 | TCGAG 866 868 | TCGAT 867 869 | TCGCA 868 870 | TCGCC 869 871 | TCGCG 870 872 | TCGCT 871 873 | TCGGA 872 874 | TCGGC 873 875 | TCGGG 874 876 | TCGGT 875 877 | TCGTA 876 878 | TCGTC 877 879 | TCGTG 878 880 | TCGTT 879 881 | TCTAA 880 882 | TCTAC 881 883 | TCTAG 882 884 | TCTAT 883 885 | TCTCA 884 886 | TCTCC 885 887 | TCTCG 886 888 | TCTCT 887 889 | TCTGA 888 890 | TCTGC 889 891 | TCTGG 890 892 | TCTGT 891 893 | TCTTA 892 894 | TCTTC 893 895 | TCTTG 894 896 | TCTTT 895 897 | TGAAA 896 898 | TGAAC 897 899 | TGAAG 898 900 | TGAAT 899 901 | TGACA 900 902 | TGACC 901 903 | TGACG 902 904 | TGACT 903 905 | TGAGA 904 906 | TGAGC 905 907 | TGAGG 906 908 | TGAGT 907 909 | TGATA 908 910 | TGATC 909 911 | TGATG 910 912 | TGATT 911 913 | TGCAA 912 914 | TGCAC 913 915 | TGCAG 914 916 | TGCAT 915 917 | TGCCA 916 918 | TGCCC 917 919 | TGCCG 918 920 | TGCCT 919 921 | TGCGA 920 922 | TGCGC 921 923 | TGCGG 922 924 | TGCGT 923 925 | TGCTA 924 926 | TGCTC 925 927 | TGCTG 926 928 | TGCTT 927 929 | TGGAA 928 930 | TGGAC 929 931 | TGGAG 930 932 | TGGAT 931 933 | TGGCA 932 934 | TGGCC 933 935 | TGGCG 934 936 | TGGCT 935 937 | TGGGA 936 938 | TGGGC 937 939 | TGGGG 938 940 | TGGGT 939 941 | TGGTA 940 942 | TGGTC 941 943 | TGGTG 942 944 | TGGTT 943 945 | TGTAA 944 946 | TGTAC 945 947 | TGTAG 946 948 | TGTAT 947 949 | TGTCA 948 950 | TGTCC 949 951 | TGTCG 950 952 | TGTCT 951 953 | TGTGA 952 954 | TGTGC 953 955 | TGTGG 954 956 | TGTGT 955 957 | TGTTA 956 958 | TGTTC 957 959 | TGTTG 958 960 | TGTTT 959 961 | TTAAA 960 962 | TTAAC 961 963 | TTAAG 962 964 | TTAAT 963 965 | TTACA 964 966 | TTACC 965 967 | TTACG 966 968 | TTACT 967 969 | TTAGA 968 970 | TTAGC 969 971 | TTAGG 970 972 | TTAGT 971 973 | TTATA 972 974 | TTATC 973 975 | TTATG 974 976 | TTATT 975 977 | TTCAA 976 978 | TTCAC 977 979 | TTCAG 978 980 | TTCAT 979 981 | TTCCA 980 982 | TTCCC 981 983 | TTCCG 982 984 | TTCCT 983 985 | TTCGA 984 986 | TTCGC 985 987 | TTCGG 986 988 | TTCGT 987 989 | TTCTA 988 990 | TTCTC 989 991 | TTCTG 990 992 | TTCTT 991 993 | TTGAA 992 994 | TTGAC 993 995 | TTGAG 994 996 | TTGAT 995 997 | TTGCA 996 998 | TTGCC 997 999 | TTGCG 998 1000 | TTGCT 999 1001 | TTGGA 1000 1002 | TTGGC 1001 1003 | TTGGG 1002 1004 | TTGGT 1003 1005 | TTGTA 1004 1006 | TTGTC 1005 1007 | TTGTG 1006 1008 | TTGTT 1007 1009 | TTTAA 1008 1010 | TTTAC 1009 1011 | TTTAG 1010 1012 | TTTAT 1011 1013 | TTTCA 1012 1014 | TTTCC 1013 1015 | TTTCG 1014 1016 | TTTCT 1015 1017 | TTTGA 1016 1018 | TTTGC 1017 1019 | TTTGG 1018 1020 | TTTGT 1019 1021 | TTTTA 1020 1022 | TTTTC 1021 1023 | TTTTG 1022 1024 | TTTTT 1023 1025 | --------------------------------------------------------------------------------