.gitignore

+web/lib
+web/plot
 a.out
 prg
 *.o

Makefile

-CXX=gcc
-CXXFLAGS=-Wall -pedantic
+C=gcc
+CLIB=-lm
+COPT=-O2
+CWARN=-Wno-unused-result
 SEQ=ATGCCCTATACCTATGATTATCCGCGCCCTGGTCTTACCGTTGACTGCGTGGTGTTTGGCCTAGACGAACAGATCGATCTCAAAGTCCTACTGATTCAGCGCCAGATTCCCCCTTTCCAGCATCAGTGGGCATTACCCGGAGGCTTTGTGCAGATGGATGAATCTTTAGAAGACGCGGCTCGCCGGGAGCTGCGAGAAGAAACGGGGGTTCAGGGTATTTTCCTAGAGCAGCTCTATACCTTTGGCGATTTGGGTCGAGATCCGCGCGATCGCATCATCTCCGTTGCCTACTACGCTCTAATCAACCTCATCGAATATCCTTTACAAGCCTCTACTGATGCTGAAGACGCAGCCTGGTACTCCATTGAGAATTTGCCATCTCTAGCTTTTGATCATGCTCAAATCTTGAAACAGGCCATCCGGCGATTGCAGGGCAAAGTTCGCTACGAACCGATTGGCTTCGAACTACTGCCGCAAAAATTTACACTCACCCAAATTCAGCAGCTTTACGAAACAGTTCTTGGCCATCCTCTAGATAAACGGAACTTTCGTAAGAAATTGCTAAAAATGGATCTCTTAATTCCCCTTGATGAGCAACAAACTGGAGTTGCTCATCGTGCTGCCAGACTCTATCAGTTCGACCAAAGCAAATACGAGCTATTGAAACAACAGGGATTTAACTTCGAGGTTTGA
-all:  prg
-run:  prg   ; ./prg 1 2 3 4 10 $(SEQ)
-prg:  dtw.c ; $(CXX) dtw.c -o prg
-clean:      ; rm -f a.out prg *~
+IN=dtw.c
+OUT=prg
+
+all: $(OUT)
+
+run: $(OUT)
+	./$(OUT) 1 2 3 4 10 100 $(SEQ)
+# ./a.out <A> <C> <G> <T> <SPEED> <RESULTS> <SEQUENCE>
+
+$(OUT): $(IN)
+	$(C) $^ -o $@ $(CLIB) $(COPT) $(CWARN)
+
+clean:
+	rm -fv a.out $(OUT) *~

docs.md

+# Zarovnávání DNA sekvencí převedených na časové řady
+
+> [_Tento dokument je dostupný online na gitlabu_](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/docs.md)  
+> _Odkazy zde uvedené budou platné do konce roku 2015_
+
+#### Ondřej Novák a Pavel Verner
+> novako20@fit.cvut.cz  
+> vernepa1@fel.cvut.cz  
+> [MI-VMV paralelka 103](https://timetable.fit.cvut.cz/old/public/cz/paralelky/C14/35/par1435506.103.html)
+
+---
+
+## [Zadání](https://edux.fit.cvut.cz/courses/MI-VMW/tutorials/start#seznam_projektu)
+
+> Bioinformatika
+
+> Zarovnávání DNA sekvencí převedených na časové řady
+
+> DNA sekvenci lze převést na časovou řadu tak, že jednotlivým bázím A,C,G,T přiřadíme váhy (např. A:1, C:2, G:-2, T:-1) a při čtení sekvence upravujeme sumu hodnot podle právě čtené báze. Aplikace by měla umožňovat vizualizaci časových řad vygenerovaných z DNA sekvencí, váhy by měly být nastavitelné (např. ve webovém formuláři) a podobnost časových řad bude řešena pomocí DTW (dynamic time warping) distance.
+
+## [Řešení](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/web/)
+
+> Webová aplikace (HTML + PHP + JS), algoritmus implementován v jazyce C
+
+> Celý projekt je dostupný veřejně na školním gitlabu:   
+> [gitlab.fit.cvut.cz/novako20/vmw-dtw](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/tree/master)
+
+> Aplikace běží na školním webdevu:  
+> [webdev.fit.cvut.cz/~novako20/vmw-dtw/web](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/web/)
+
+---
+
+### Popis projektu
+Cílem projektu je určování podobnosti mezi DNA sekvencemi za využití [DTW algoritmu](https://en.m.wikipedia.org/wiki/Dynamic_time_warping). Vstupem je sekvence tvořená ACGT řetězcem, výstupem jsou nejpodobnější sekvence z vlastního vzorku, seřazené dle vypočítaného DTW skóre.
+
+### Způsob řešení
+Základním prvkem řešení je samotný DTW algoritmus. Dynamic Time Warping je algoritmus dynamického programování, vyplňuje se tabulka o rozměru `<délka d1 vstupní sekvence> x <délka d2 testové sekvence>`, složitost (časová i prostorová) je tedy kvadratická. Jedná se vlastně o matici, která se postupně vyplňuje podle doposud vypočítaných hodnot. Výsledkem je cesta spojující protilehlé rohy matice a navíc splňující určitá další kritéria, o tom [více v přednášce](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/dtw/dtw_2.png).
+
+Tato cesta znamená, kterak se na sebe napojují jednotlivé úseky sekvencí (lokální _natahování_), lze tedy měřit podobnost sekvencí různých délek, ne jen čistě vektorově měřením podobnosti po složkách. Ilustrace takového výsledného napojení je opět [k vidění v přednášce](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/dtw/dtw_1.png).
+
+Jako testové sekvence jsou použity sekvence z genomů bakterií dostupných na [genbank od NCBI](http://ftp.ncbi.nlm.nih.gov/genomes/archive/old_genbank/Bacteria/) (_National Center for Biotechnology Information_). Z každého genomu je vybrán první soubor typu _ffn_ a z toho se vezme první DNA sekvence. Postup získávání těchto testových sekvencí je také k nahlédnutí mezi zdrojovými soubory v [adresáři data](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/tree/master/data).
+
+### Implementace
+DTW algoritmus je naimplementován v jazyce C, [zdrojový kód je na gitlabu](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/dtw.c). Zde nejsou použity žádné externí knihovny s výjimkou standardních [`stdlib stdio string math`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/dtw.c#L1-L4). Implementovány jsou funkce [`dtw`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/dtw.c#L12) a [`dtw_fast`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/dtw.c#L62). *dtw* vyplňuje celou matici, zatímco *dtw_fast* má parametr určující oblast, která se prohledává - tím lze výpočet zrychlit, ale na druhou stranu pak nemusí být nalezeno nejlepší řešení. Oblast prohledávání je pás konstantní šírky okolo diagonály, jedná se o řešení [_Sakoe-Chiba band_](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/dtw/dtw_3.png).
+
+Program se volá s parametrem [`speed`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/usage.txt#L4-L5) určujícím, jak velká část matice se bude vyplňovat, a teprve z toho se [vypočítá koeficient](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/dtw.c#L73-L76) udávající šířku pásu `p = <percentage> => w = (1 - sqrt(1 - p))`. [Výraz vysvětlen](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/docs_w.png) i s vypočteným příkladem.
+
+Všechny parametry volání jsou [popsány zde](http://webdev.fit.cvut.cz/~novako20/vmw-dtw/usage.txt). Tato hláška je součástí programu a vypíše se při nesprávném spuštění. Součástí zdrojových souborů je i [Makefile](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/Makefile) pro automatickou kompilaci a ukázkové spuštění. Aplikace se na dané platformě zkompiluje příslušným C-kompilátorem, a může tedy běžet na Windows i na Linuxu.
+
+Samotný web je postavený jako jedna stránka [index.php](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/web/index.php) obsahující formulář pro zadání parametrů výpočtu. Formulář má celkem 4 sekce k vyplnění: _vstup_ (vstupní sekvence), _váhy_ (váhy jednotlivých bází), _výstup_ (počet sekvencí vykreslených v grafu a celkově počet zobrazených výsledků) a _výpočet_ (procentuální oblast pro zrychlený výpočet). Jedná se pouze html kód, inline stylování, javascript na předvyplnění formuláře a konečně php skripty pro dynamické generování obsahu stránky na základě odeslaného formuláře. Navíc použita externí php knihovna [pChart](http://wiki.pchart.net/) pro vykreslení grafu. Požadavkem na běh je pak pouze funkční webserver s podporou php.
+
+### Příklad výstupu
+[Ukázkový vstup a zobrazení výsledku v aplikaci](http://webdev.fit.cvut.cz/~novako20/vmw-dtw/web/showcase.png)
+
+Stejného výsledku lze dosáhnout na [webu aplikace](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/web/) po zmáčknutí tlačítka `UKÁZKOVÝ VSTUP` a následně `SPUSTIT VÝPOČET`
+
+### Experimentální sekce
+Základním parametrem ovlivňujícím rychlost (ale i přesnost) je již výše diskutovaný parametr [`speed`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/usage.txt#L4-L5). Jeho vliv je zdokumentován ve výstupem testovacího skiptu [`time.sh`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/time.sh), ten ukládá výstupy jednotlivých běhů do společného [adresáře](http://webdev.fit.cvut.cz/~novako20/vmw-dtw/time/), a lze tak zjistit rozdíly mezi vypočtenými hodnotami v rámci jedné zadané vstupní sekvence. Samotný skript pak poskytuje [výstup v podobě doby běhu](http://webdev.fit.cvut.cz/~novako20/vmw-dtw/time/time.txt), která je ve výše uvedeném adresáři taktéž k vidění.
+
+Zde je navíc vidět podstatné zlepšení časů při kompilaci se [zapnutou optimalizací](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/Makefile#L3). Pro porovnání je zobrazen i výsledek měření nasazené aplikace na webdevu - celkový čas `real` je lepší, nicméně výpočetní čas `user` vychází lépe při lokálním testování. Při běhu programu pak samozřejmě záleží také na omezeních uživatelského účtu, pod kterým se spouštějí php skripty (který spustí tento výpočetní program).
+
+Posledním naimplementovaným vylepšením je [přeskakování shodných sekvencí](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/commit/ba62439ce8f743b0a0ffb95fe28f75c368b2c436). Ve výsledcích se totiž objevovaly shodné výsledky pro několik po sobě jdoucích testových sekvencí. To je způsobené shodou DNA sekvence na začatku genomu, která byla použita jako vzorek pro testové sekvence. Jelikož jsou sekvence seřazené dle jména, lze předpokládat, že shodné sekvence se budou vyskytovat za sebou. Po přečtení následující sekvence se tedy zkontroluje, zda neodpovídá předcházející sekvenci, a pokud ano, předchází bez dalšího výpočtu se na další testový vzorek.
+
+### Diskuze
+Algoritmus DTW je dobře známý a jeho implementace přímočará, nicméně i tam lze dosáhnout podstatného zlepšení, a to paralelizováním výpočtu. Výpočty pro jednotlivé testové sekvence jsou vzájemně nezávislé, akorát by se zvýšila paměťová náročnost, jelikož každá právě testovaná sekvence by musela mít vlastní matici pro výpočet DTW skóre.
+
+Veškerá další vylepšení tedy spočívají v optimalizaci věcí okolo. Jedná se zejména o čtení ze souborového systému. Všechny testové sekvence by mohly být v jednom souboru, případně lze uvažovat i o vlastním binárním kódování `A C G T => 00 01 10 11`, tím se zmenší velikost souboru. Pro maximální rychlost lze úplně eliminovat čtení z disku vypsáním sekvencí přímo do zdrojového souboru. Dále by šlo efektivně řešit vypisování výsledků. Nyní se pro každý jednotlivý výsledek projde celé pole výsledků. Při větším počtu zobrazených výsledků (případně všechny) je lepší nejprve pole seřadit a pak teprve sekvenčně vypsat. Kde je optimální hranice mezi postupným procházením a seřazením lze zjistit experimentálně.
+
+Co se týká webové prezentace, lze dále rozvinout vizualizaci. Nyní je implementováno generování obrázku ze zdrojových dat. Graf by mohl být vytvořen i interaktivní nativně pomocí javascriptu. Navíc by šlo vizualizaci dále informačně obohatit například zobrazením [vodícíh linek](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/dtw/dtw_1.png), které ozřejmí, jakým způsobem jsou na sebe sekvence navázány (tuto informaci dává právě ona zvolená cesta ve výpočetní matici).
+
+### Závěr
+Cílem zde bylo seznámit se s konkrétní technikou nacházení podobností (DTW algoritmus) a aplikovat ji v konkrétní oblasti použítí (DNA sekvence v bioinformatice). Po seznámení s principem fungování DTW jsme naimplementovali základní plně kvadratickou verzi [`dtw`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/dtw.c#L12) a prokročilou rychlejší verzi [`dtw_fast`](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/blob/master/dtw.c#L62). Rychlejší verze však nemusí najít optimální výsledek, jelikož nebere v úvahu všechna možná řešení.
+
+Webovou aplikaci pak tvoří formulář, kam se zadá vstupní sekvence spolu s dalšími parametry výpočtu. Po odeslání se na pozadí spustí program implementující DTW algoritmus a výsledky jsou následně zobrazeny ve formě grafu a tabulky s vypsanými sekvencemi seřazenými dle vypočítaného skóre podobnosti. 
+
+Pro vývoj projektu byla využita školní infrastura: [gitlab](https://gitlab.fit.cvut.cz/novako20/vmw-dtw/tree/master) pro správu zdrojových souborů a [webdev](https://webdev.fit.cvut.cz/~novako20/vmw-dtw/web/) pro nasazení aplikace.

dtw.c

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <math.h>
 
 #define TEST_CNT 2740 // 2740 // # of test sequences to compare (up to 9999)
 #define TEST_MAX 8992 // 8992 // length of longest test sequence + 1
-#define RESULTS    10 // # of results to display
+// #define RESULTS   100 // # of results to display
 
 // #define DEBUG
 
@@ -59,16 +60,21 @@ int dtw (int ** dtwm, int * seq1, int seq1_len, int * seq2, int seq2_len) {
 }
 
 int dtw_fast (int speed, int ** dtwm, int * seq1, int seq1_len, int * seq2, int seq2_len) {
-	if (speed <= 0 || speed >= 100) return dtw(dtwm, seq1, seq1_len, seq2, seq2_len);
+	if (speed < 5 || speed > 95) return dtw(dtwm, seq1, seq1_len, seq2, seq2_len);
 
 	int i, j;
 	int dif, min;
 
-	float w = (float) speed / 100;         // speed of computation, lower => faster but not necessarily precise
-	float r = (float) seq2_len / seq1_len; // ratio of lengths of given sequences
+	double w = (double) speed / 100;         // speed of computation, lower => faster but not necessarily precise
+	double r = (double) seq2_len / seq1_len; // ratio of lengths of given sequences
 	int begin, end;  // first and last index in current row to be computed
 	int first, last; // first and last index which was computed in preceding row
 
+	// recompute to match desired speed
+	// => <speed> % of matrix is filled
+	// (expression explained in docs)
+	w = (1 - sqrt(1-w));
+
 	// index [0][0] of DTW matrix
 	dif = seq1[0] - seq2[0]; // metric is absolute value |x-y|
 	if (dif < 0) dif = -dif;
@@ -172,15 +178,17 @@ void sum (const char * arg, int * seq, int seq_len, int * tab) {
 }
 
 int main (int argc, char * argv[]) {
-	if (argc != 7) {
+	if (argc != 8) {
 		fprintf(
 			stderr,
-			"Usage: %s <A> <C> <G> <T> <SPEED> <SEQUENCE>\n\n"
-			"\t<A/C/G/T>  - int values for sequence conversion, usually in range [-10,10]\n"
-			"\t<SPEED>    - int value (percentage) telling how far you can go off the diagonal,\n"
+			"Usage: %s <A> <C> <G> <T> <SPEED> <RESULTS> <SEQUENCE>\n\n"
+			"\t<A/C/G/T>  - int values for sequence conversion\n"
+			"\t<SPEED>    - %% meaning how far the path can go off the diagonal,\n"
 			"\t             from 5 (very fast, not precise) to 100 (full computation)\n"
+			"\t<RESULTS>  - # of results to output as <DTW score>:<sequence number>,\n"
+			"\t             currently %d test sequences available\n"
 			"\t<SEQUENCE> - DNA sequence made of A/C/G/T letters\n",
-			argv[0]
+			argv[0], TEST_CNT
 		);
 		return 1;
 	}
@@ -189,14 +197,18 @@ int main (int argc, char * argv[]) {
 
 	int speed;            // speed (but also precision) of computation
 	int tab[4];           // A/C/G/T conversion values
+	int results;          // # of results to output
 	int res[TEST_CNT];    // resulting DTW score for each comparison
-	int * seq, seq_len;	  // one input sequence
+	int * seq, seq_len;	  // input sequence (argument)
 	int * test, test_len; // current test sequence
+	int test_len_lag;     // previous test sequence
 	int ** dtwm;          // DTW matrix for computation
 
-	FILE * fp = NULL;     // file containing test DNA sequence
-	char test_path[16];   // "./test/0000.seq"
-	char test_str[TEST_MAX];
+	FILE * fp = NULL;         // file containing test DNA sequence
+	char test_path[16];       // test sequence "./test/0000.seq"
+	char test_str0[TEST_MAX]; // array to store test sequence
+	char test_str1[TEST_MAX]; // array to check if next seq is equal
+	char * test_str = NULL;   // pointing to one of test_str{0,1}
 
 	seq_len = strlen(argv[argc-1]);
 	seq  = (int *)  malloc (sizeof(int)  * seq_len);
@@ -205,14 +217,26 @@ int main (int argc, char * argv[]) {
 	for (i = 0; i < seq_len; i++) dtwm[i] = (int *) malloc (sizeof(int) * TEST_MAX);
 
 	for (i = 0; i < 4; i++) tab[i] = atoi(argv[i+1]);
-	speed = atoi(argv[i+1]);
+	speed   = atoi(argv[i+1]);
+	results = atoi(argv[i+2]);
+	if (results < 0) results = 10;
+	if (results > TEST_CNT) results = TEST_CNT;
+
+	test_len_lag = 0;
 	sum(argv[argc-1], seq, seq_len, tab);
 	for (i = 0; i < TEST_CNT; i++) {
 		sprintf(test_path, "./test/%d.seq", i);
 		fp = fopen(test_path, "r");
+		test_str = (i % 2) ? test_str1 : test_str0;
 		fscanf(fp, "%s", test_str);
 		fclose(fp);
 		test_len = strlen(test_str);
+		if (test_len == test_len_lag && !strcmp(test_str0, test_str1)) {
+			// skip sequence if equal to previous
+			res[i] = -1;
+			continue;
+		}
+		test_len_lag = test_len;
 		sum(test_str, test, test_len, tab);
 		res[i] = dtw_fast(speed, dtwm, seq, seq_len, test, test_len);
 		#ifdef DEBUG
@@ -220,16 +244,19 @@ int main (int argc, char * argv[]) {
 		#endif
 	}
 
-	for (j = 0; j < RESULTS; j++) {
-		i = 0;
-		while (res[i] < 0) i++;
-		x = i;
-		for (i++; i < TEST_CNT; i++) {
+	for (j = 0; j < results; j++) {
+		x = 0;
+		while (x < TEST_CNT && res[x] < 0) x++;
+		for (i = x + 1; i < TEST_CNT; i++) {
 			if (res[i] < res[x] && res[i] >= 0) x = i;
 		}
-		// <DTW score>:<test file number>
-		printf("%d:%d\n", res[x], x);
-		res[x] = -1;
+		// x can be == TEST_CNT because of skipping
+		if (x == TEST_CNT) printf("-1:-1\n");
+		else {
+			// <DTW score>:<test sequence number>
+			printf("%d:%d\n", res[x], x);
+			res[x] = -1;
+		}
 	}
 
 	for (i = 0; i < seq_len; i++) free(dtwm[i]);

readme.md

-### Zarovnávání DNA sekvencí převedených na časové řady
-
-DNA sekvenci lze převést na časovou řadu tak, že jednotlivým bázím A,C,G,T přiřadíme váhy (např. A:1, C:2, G:-2, T:-1) a při čtení sekvence upravujeme sumu hodnot podle právě čtené báze. Aplikace by měla umožňovat vizualizaci časových řad vygenerovaných z DNA sekvencí, váhy by měly být nastavitelné (např. ve webovém formuláři) a podobnost časových řad bude řešena pomocí DTW (dynamic time warping) distance.
-
-Edux: [MI-VMW](https://edux.fit.cvut.cz/courses/MI-VMW/tutorials/start#seznam_projektu)
-
-Data: [Genbank](ftp://ftp.ncbi.nih.gov/genbank/genomes/Bacteria/) (soubory typu *.ffn)
-
-Wiki: [DTW](https://en.m.wikipedia.org/wiki/Dynamic_time_warping)
+### Zarovnávání DNA sekvencí převedených na časové řady
+
+DNA sekvenci lze převést na časovou řadu tak, že jednotlivým bázím A,C,G,T přiřadíme váhy (např. A:1, C:2, G:-2, T:-1) a při čtení sekvence upravujeme sumu hodnot podle právě čtené báze. Aplikace by měla umožňovat vizualizaci časových řad vygenerovaných z DNA sekvencí, váhy by měly být nastavitelné (např. ve webovém formuláři) a podobnost časových řad bude řešena pomocí DTW (dynamic time warping) distance.
+
+[Dokumentace](docs.md)

time.sh

+SEQ=ATGCCCTATACCTATGATTATCCGCGCCCTGGTCTTACCGTTGACTGCGTGGTGTTTGGCCTAGACGAACAGATCGATCTCAAAGTCCTACTGATTCAGCGCCAGATTCCCCCTTTCCAGCATCAGTGGGCATTACCCGGAGGCTTTGTGCAGATGGATGAATCTTTAGAAGACGCGGCTCGCCGGGAGCTGCGAGAAGAAACGGGGGTTCAGGGTATTTTCCTAGAGCAGCTCTATACCTTTGGCGATTTGGGTCGAGATCCGCGCGATCGCATCATCTCCGTTGCCTACTACGCTCTAATCAACCTCATCGAATATCCTTTACAAGCCTCTACTGATGCTGAAGACGCAGCCTGGTACTCCATTGAGAATTTGCCATCTCTAGCTTTTGATCATGCTCAAATCTTGAAACAGGCCATCCGGCGATTGCAGGGCAAAGTTCGCTACGAACCGATTGGCTTCGAACTACTGCCGCAAAAATTTACACTCACCCAAATTCAGCAGCTTTACGAAACAGTTCTTGGCCATCCTCTAGATAAACGGAACTTTCGTAAGAAATTGCTAAAAATGGATCTCTTAATTCCCCTTGATGAGCAACAAACTGGAGTTGCTCATCGTGCTGCCAGACTCTATCAGTTCGACCAAAGCAAATACGAGCTATTGAAACAACAGGGATTTAACTTCGAGGTTTGA
+
+make
+
+for i in "005" "010" "025" "050" "100"
+do
+    echo time ./prg $i %
+    time ./prg 1 2 3 4 $i 100 $SEQ 2>&1 | tee ./time/time$i.txt >/dev/null
+    echo
+done

time/time.txt

+default compilation	optimization -O2	optimization -O2 @ webdev
+
+time ./prg 005 %	time ./prg 005 %	time ./prg 005 %
+		
+real	0m5.829s	real	0m3.644s	real	0m1.981s
+user	0m1.938s	user	0m0.402s	user	0m1.512s
+sys	0m2.108s	sys	0m1.442s	sys	0m0.480s
+		
+time ./prg 010 %	time ./prg 010 %	time ./prg 010 %
+		
+real	0m9.014s	real	0m4.218s	real	0m2.831s
+user	0m5.160s	user	0m0.727s	user	0m2.400s
+sys	0m1.760s	sys	0m1.723s	sys	0m0.448s
+		
+time ./prg 025 %	time ./prg 025 %	time ./prg 025 %
+		
+real	0m18.925s	real	0m6.601s	real	0m5.537s
+user	0m14.338s	user	0m2.476s	user	0m5.076s
+sys	0m1.766s	sys	0m2.027s	sys	0m0.472s
+		
+time ./prg 050 %	time ./prg 050 %	time ./prg 050 %
+		
+real	0m34.363s	real	0m10.394s	real	0m9.478s
+user	0m28.545s	user	0m6.116s	user	0m8.768s
+sys	0m2.833s	sys	0m1.817s	sys	0m0.708s
+		
+time ./prg 100 %	time ./prg 100 %	time ./prg 100 %
+		
+real	0m54.972s	real	0m16.339s	real	0m14.958s
+user	0m48.706s	user	0m11.345s	user	0m14.236s
+sys	0m3.102s	sys	0m2.388s	sys	0m0.640s
+		

time/time005.txt

+0:0
+663:2656
+676:1143
+781:942
+783:2107
+806:2105
+823:2452
+849:530
+877:554
+982:1812
+1148:2087
+1340:1515
+1352:1269
+1514:2029
+1516:964
+1652:2159
+1707:881
+2228:1562
+2428:1249
+3265:1941
+3816:962
+3899:247
+4158:1507
+4667:1742
+5059:2405
+7120:2463
+7683:547
+7824:1020
+8080:549
+8552:1743
+8652:2092
+10311:246
+11224:1224
+11530:30
+11846:1979
+11924:734
+13347:2088
+13547:1170
+13808:837
+14174:548
+14193:2459
+15975:948
+18362:2557
+18410:927
+19384:1102
+21970:2561
+22206:753
+23566:2467
+27018:1510
+27601:873
+28653:1024
+29148:1501
+30416:1003
+30982:1184
+30994:1986
+31218:1543
+31791:2716
+33517:2086
+34371:360
+34484:1898
+35129:362
+35698:1036
+35963:2003
+37442:2264
+37701:900
+37878:2456
+38378:2142
+39042:78
+39637:551
+41187:265
+42454:1286
+42988:2468
+43392:557
+43405:276
+43632:2313
+43719:338
+45143:2180
+46036:897
+47107:2220
+48176:1822
+48279:550
+48836:824
+48925:1004
+51777:2541
+51962:509
+52022:888
+52736:855
+53103:499
+54329:1493
+56606:1502
+57044:2050
+57081:2691
+57279:1469
+57484:2079
+57846:2043
+58103:2071
+58103:2073
+58691:2059
+58782:1300
+59162:2080

time/time010.txt

+0:0
+628:1941
+663:2656
+666:1143
+781:942
+783:2107
+800:1515
+806:2105
+823:2452
+849:530
+877:554
+884:2087
+890:1269
+944:1562
+980:1812
+1023:881
+1111:30
+1163:964
+1171:547
+1254:2029
+1269:1249
+1317:2159
+1390:549
+1513:247
+1577:837
+1646:1507
+1646:1742
+1930:962
+1942:1979
+2082:1743
+2137:548
+2144:2463
+2272:2088
+2409:2405
+2528:948
+2530:1170
+2616:2092
+3263:1020
+3300:246
+3330:734
+4048:2557
+4809:1224
+5610:2459
+6403:927
+6923:2467
+7302:2561
+9271:1102
+10840:753
+12561:1184
+13520:1510
+13633:873
+13661:1898
+14731:1501
+14823:1986
+15023:2456
+15207:1003
+16090:2264
+16324:2716
+16841:1024
+16968:1543
+17039:2086
+17087:1036
+17413:2003
+18549:551
+19476:2142
+19486:78
+21156:265
+21815:900
+22479:360
+23125:362
+23606:276
+24240:338
+24549:2313
+25845:2180
+26020:550
+26038:1286
+26589:2468
+26762:557
+27093:824
+27242:1822
+28580:1004
+28702:2220
+29358:897
+31090:2541
+32748:855
+32754:888
+32945:499
+33053:1493
+33852:1502
+34362:1469
+34799:509
+35553:1300
+37312:2050
+37487:2691
+37687:2079
+37731:196
+37997:2071
+37997:2073
+38089:2043
+38240:2059

time/time025.txt

+0:0
+628:1941
+663:2656
+666:1143
+781:942
+783:2107
+800:1515
+806:2105
+823:2452
+849:530
+877:554
+884:2087
+890:1269
+944:1562
+980:1812
+1023:881
+1111:30
+1163:964
+1171:547
+1254:2029
+1269:1249
+1317:2159
+1390:549
+1416:948
+1513:247
+1577:837
+1646:1507
+1646:1742
+1922:1979
+1930:962
+2026:548
+2082:1743
+2113:1170
+2144:2463
+2220:2088
+2365:2092
+2409:2405
+2570:246
+2617:2456
+2844:734
+2931:2557
+2939:2467
+3031:1020
+3102:2561
+3446:1224
+3623:2459
+3705:927
+3788:1898
+3841:1184
+4362:2264
+4804:265
+4813:2003
+5165:1986
+5170:1036
+5326:2313
+5433:551
+5551:824
+5627:753
+5735:1510
+5815:873
+5932:1501
+5952:338
+6393:550
+6467:2716
+6503:1102
+6904:1004
+6908:1003
+7157:1822
+7191:2142
+7331:2220
+7403:2468
+7624:2086
+7665:78
+7704:276
+7713:1469
+7747:2541
+7825:900
+8016:1024
+8076:1543
+8712:2180
+9692:196
+10242:360
+10444:362
+10641:1094
+10709:1493
+10785:2496
+10832:1285
+10927:897
+11149:1286
+11154:327
+11369:499
+11465:888
+11756:557
+11913:1656
+11913:1666
+12054:855
+12100:2454
+12319:1664
+12516:1663
+12516:1665

time/time050.txt

+0:0
+628:1941
+663:2656
+666:1143
+781:942
+783:2107
+800:1515
+806:2105
+823:2452
+849:530
+877:554
+884:2087
+890:1269
+944:1562
+980:1812
+1023:881
+1111:30
+1163:964
+1171:547
+1254:2029
+1269:1249
+1317:2159
+1390:549
+1416:948
+1513:247
+1577:837
+1646:1507
+1646:1742
+1922:1979
+1930:962
+2026:548
+2082:1743
+2113:1170
+2144:2463
+2220:2088
+2365:2092
+2409:2405
+2570:246
+2617:2456
+2844:734
+2931:2557
+2939:2467
+3031:1020
+3102:2561
+3446:1224
+3623:2459
+3705:927
+3788:1898
+3841:1184
+4362:2264
+4804:265
+4813:2003
+5165:1986
+5170:1036
+5326:2313
+5433:551
+5551:824
+5627:753
+5735:1510
+5815:873
+5932:1501
+5952:338
+6393:550
+6467:2716
+6503:1102
+6904:1004
+6908:1003
+7157:1822
+7191:2142
+7331:2220
+7403:2468
+7624:2086
+7665:78
+7704:276
+7713:1469
+7747:2541
+7825:900
+8016:1024
+8076:1543
+8712:2180
+9692:196
+10242:360
+10444:362
+10641:1094
+10709:1493
+10779:2496
+10832:1285
+10927:897
+11128:327
+11149:1286
+11369:499
+11465:888
+11756:557
+11913:1656
+11913:1666
+11934:2454
+12054:855
+12272:413
+12319:1664
+12516:1663

time/time100.txt

+0:0
+628:1941
+663:2656
+666:1143
+781:942
+783:2107
+800:1515
+806:2105
+823:2452
+849:530
+877:554
+884:2087
+890:1269
+944:1562
+980:1812
+1023:881
+1111:30
+1163:964
+1171:547
+1254:2029
+1269:1249
+1317:2159
+1388:549
+1416:948
+1513:247
+1577:837
+1646:1507
+1646:1742
+1922:1979
+1930:962
+2024:548
+2082:1743
+2113:1170
+2144:2463
+2218:2088
+2365:2092
+2409:2405
+2570:246
+2617:2456
+2844:734
+2931:2557
+2939:2467
+3031:1020
+3102:2561
+3446:1224
+3623:2459
+3705:927
+3788:1898
+3841:1184
+4362:2264
+4802:265
+4813:2003
+5165:1986
+5170:1036
+5326:2313
+5431:551
+5551:824
+5627:753
+5735:1510
+5813:873
+5932:1501
+5950:338
+6393:550
+6465:2716
+6503:1102
+6904:1004
+6908:1003
+7157:1822
+7191:2142
+7331:2220
+7403:2468
+7624:2086
+7665:78
+7704:276
+7713:1469
+7747:2541
+7825:900
+8016:1024
+8074:1543
+8712:2180
+9692:196
+10240:360
+10442:362
+10641:1094
+10707:1493
+10779:2496
+10832:1285
+10927:897
+11128:327
+11149:1286
+11369:499
+11465:888
+11756:557
+11913:1656
+11913:1666
+11934:2454
+12054:855
+12272:413
+12319:1664
+12516:1663

usage.txt

+Usage: ./prg <A> <C> <G> <T> <SPEED> <RESULTS> <SEQUENCE>
+
+	<A/C/G/T>  - int values for sequence conversion
+	<SPEED>    - % meaning how far the path can go off the diagonal,
+	             from 5 (very fast, not precise) to 100 (full computation)
+	<RESULTS>  - # of results to output as <DTW score>:<sequence number>,
+	             currently 2740 test sequences available
+	<SEQUENCE> - DNA sequence made of A/C/G/T letters