First commit - second part

Former-commit-id: 202296404e6a70f8ae96db99faffb456104c57e9
Former-commit-id: 118417735d2055683607df9809c9b721cc1b1bab

src/prokov/lxpack/Makefile

@@ -0,0 +1,29 @@
+# ---------------------------------------------------------------
+# $Id: $
+# ---------------------------------------------------------------
+# @file: Makefile
+# @desc: makefile for prokov
+#
+# @history:
+# @history:
+# @+	    <Gloup> : Apr 97 : Created
+# @+	    <Gloup> : Mar 02 : Updated for LXxware
+#
+# @note: should be processed with gnu compatible make
+# @note: helixware_compatible
+#
+# @end:
+# ---------------------------------------------------------------
+#
+include ./config/auto.conf
+
+DIRS = src \
+       tests
+
+include ./config/targets/propagate.targ
+
+include ./config/targets/help.targ
+
+portclean::
+	$(MAKE) ACTION=$@ _action
+	(! test -d $(PRTDIR)) || \rm -r $(PRTDIR)

src/prokov/lxpack/config/README.txt

@@ -0,0 +1,51 @@
+
+$Id: README.txt 1825 2013-02-26 09:39:47Z viari $
+
+This directory contains Makefile machine specific configuration files
+(and default targets to help you writing Makefile's)
+
+These headers should be used with GNU make or compatible
+
+#
+# portname
+#
+
+To check your port, issue :
+
+  ./guess_port
+  
+  if output is 'unknown <mach>:<sys>:<rel>' then you should :
+    - add a port entry in guess_port for <mach>:<sys>:<rel>
+    - create a ports/<port>.conf configuration file
+      (the best is to start from another port file,
+       choose whatever looks closest)
+
+#
+# configuration flags
+#
+
+auto.conf : the main configuration file :
+             - determine the machine port thru 'guess_port' shell
+             - include 'default.conf' file
+             - include the machine specific 'ports/<port>.conf' file
+
+default.conf : default configuration (included by 'auto.conf')
+
+ports/<port>.conf  : machine specific configuration (included by 'auto.conf')
+
+#
+# utility targets
+#
+
+targets/help.targ : target for standard help
+
+targets/propagate.targ : target for propagating targets to subdirectories
+
+targets/package.targ : default targets for standard package with 'configure'
+
+targets/empty.targ : default empty targets (defined as double colon rules)
+
+targets/lxbin.targ : default make targets for standard lx binary (without libraries)
+
+targets/debug.targ : target to print debug information (for dev.)
+

src/prokov/lxpack/config/auto.conf

@@ -0,0 +1,54 @@
+#
+# $Id: auto.conf 1825 2013-02-26 09:39:47Z viari $
+#
+# auto.conf
+# auto configuration file using guess_port
+#
+# this file is included in Makefile
+#
+
+#
+# default shell for gnu-make
+#
+
+SHELL = /bin/sh
+
+#
+# CFGDIR : location of config files = this file directory location
+#
+# CFGPRT : port name (as returned by guess_port)
+#
+
+# because builtin 'lastword' is missing in gnu-make 3.80
+
+lastword = $(word $(words $1), $1)
+
+CFGDIR := $(dir $(call lastword, $(MAKEFILE_LIST)))
+
+CFGPRT := $(shell $(CFGDIR)guess_port)
+
+# check if port is correctly defined
+
+ifneq (1, $(words $(CFGPRT)))
+  entry := $(call lastword, $(CFGPRT))
+  $(error port is undefined - add entry for "$(entry)" in configuration file -)
+endif
+
+#
+# PORTNAME : port name to use : default is CFGPRT but may be futher modified
+#            by machine specific configuration
+
+PORTNAME = $(CFGPRT)
+
+#
+# default configuration
+# may be overriden by machine dependant definitions below
+#
+
+include $(CFGDIR)default.conf
+
+#
+# machine dependant definitions
+#
+
+include $(CFGDIR)ports/$(CFGPRT).conf

src/prokov/lxpack/config/default.conf

@@ -0,0 +1,124 @@
+#
+# $Id: default.conf 2007 2013-12-03 14:21:39Z viari $
+#
+# default.conf
+# default configuration flags
+# maybe further redefined by machine specific configuration
+#
+# this file is included by auto.conf
+#
+
+# ------------------------------------
+# General compilation flags
+# ------------------------------------
+
+#
+# MACHDEF : define machine and OS specific flags
+#
+
+MACHDEF = 
+
+#
+# CC : (ansi C) compiler command to use
+#      you may add some machine specific flags (like -arch ...)
+#      in the <machine>.conf configuration file
+#
+
+CC = gcc
+
+#
+# default compiler optimizer flag
+#
+
+OPTIM =	-O
+
+#
+# CC_LIBS : additionnal machine specific $(CC) libraries
+#           like '-lC' on some machines
+#
+
+CC_LIBS = 
+
+#
+# MALLOC_LIBS : machine specific malloc librairies
+#               like '-lmalloc' on SGI
+#
+
+MALLOC_LIBS = 
+
+#
+# MATH_LIBS : machine specific math librairies
+#           like '-lm' on Solaris
+#
+
+MATH_LIBS = 
+
+#
+# LINT : looks like LINT command does not exist anymore
+#        here is a rough replacement
+#
+
+LINT = gcc -S -Wall -Wno-format-y2k -W -Wstrict-prototypes       \
+              -Wmissing-prototypes -Wpointer-arith -Wreturn-type \
+              -Wcast-qual -Wwrite-strings -Wswitch -Wshadow      \
+              -Wcast-align -Wbad-function-cast -Wchar-subscripts \
+              -Winline -Wnested-externs -Wredundant-decls
+
+# ------------------------------------
+# General system commands
+# ------------------------------------
+
+#
+# AR : AR archive command
+# ARFLAGS : $(AR) archiving flags 
+# ARXFLAGS : $(AR) extraction flags 
+#
+
+AR = ar
+ARFLAGS = rcv
+ARXFLAGS = xv
+
+#
+# RANLIB : ranlib command
+#
+
+RANLIB = ranlib
+
+#
+# DIFF : diff command
+#
+
+DIFF = diff
+
+#
+# TAR : tar command
+#
+
+TAR = tar
+
+# ------------------------------------
+# Default locations
+# ------------------------------------
+#
+# PRTDIR : port dependent files location (libraries and binaries)
+# BINDIR : port binaries
+# LIBDIR : port libraries
+#
+
+PRTDIR   =	$(CFGDIR)../ports/$(PORTNAME)
+
+BINDIR   =  $(PRTDIR)/bin
+
+LIBDIR	 =	$(PRTDIR)/lib
+
+# ------------------------------------
+# default gmake variable in implicit rules
+# ------------------------------------
+
+CFLAGS 	  = 	$(OPTIM) $(MACHDEF) -I$(INCDIR)
+
+LDFLAGS	  =     -L$(LIBDIR) -L.
+
+LDLIBS	  =	    $(LIBS) $(MALLOC_LIBS) $(MATH_LIBS) $(CC_LIBS)
+
+LINTFLAGS = 	$(MACHDEF) -I$(INCDIR)

src/prokov/lxpack/config/guess_port

@@ -0,0 +1,33 @@
+#! /bin/sh
+# 
+# $Id: guess_port 1825 2013-02-26 09:39:47Z viari $
+#
+# @file: guess_port
+# @desc: attempt to guess the portname
+# @usage: guess_port
+#
+# @history:
+# @+ <Gloup> Nov. 2000 first draft adapted from GNU config.guess
+# @+ <Gloup> Feb. 2010 moved to sh
+#
+
+mach=`uname -m`
+syst=`uname -s`
+rels=`uname -r`
+
+case ${mach}:${syst}:${rels} in
+
+    alpha:OSF1:*     )  echo alpha-osf1;;
+    sun4*:SunOS:5.*  )  echo sparc-solaris;;
+    i86pc:SunOS:5.*  )  echo i386-solaris;;
+    sun4*:SunOS:*    )  echo sparc-sunos;;
+    Power*:Darwin:*  )  echo ppc-darwin;;
+    i*86:Linux:*     )  echo i386-linux;;
+    x*86*:Linux:*    )  echo i386-linux;;
+    i*86:Darwin:*    )  echo i386-darwin;;
+    IP*:IRIX*:*      )  echo mips-irix;;
+    i*86:MINGW32*:*  )  echo x86-mingw32;;
+    
+    *) echo unknown ${mach}:${syst}:${rels}; exit 1;;
+esac
+exit 0

src/prokov/lxpack/config/ports/i386-darwin.conf

@@ -0,0 +1,26 @@
+#
+# $Id: i386-darwin.conf 1825 2013-02-26 09:39:47Z viari $
+#
+# i386-darwin.conf
+# configuration file for MacOS-X/Intel-Based/Darwin 1.2 with gcc compiler
+# this file is included in Makefile
+#
+# system (uname -srp) : Darwin 8.7.1 i386
+# compiler (cc --version) : i686-apple-darwin8-gcc-4.0.1
+#
+# check tags
+# @uname:uname -srp:Darwin 8.7.1 i386
+# @cc:cc --version:i686-apple-darwin8-gcc-4.0.1
+#
+#
+
+# ------------------------------------
+# General compilation flags
+# ------------------------------------
+
+#
+# MACHDEF : define machine and OS specific flags
+#
+
+MACHDEF = -DLX_TARGET_MACINTEL -DLITTLE_ENDIAN -DMACOSX
+

src/prokov/lxpack/config/ports/i386-linux.conf

@@ -0,0 +1,32 @@
+#
+# $Id: i386-linux.conf 1825 2013-02-26 09:39:47Z viari $
+#
+# i386-linux.conf
+# configuration file for linux ix86 with GNU gcc compiler
+# this file is included in Makefile
+#
+# system (uname -srp) : Linux 2.2.14-5.0 unknown
+# compiler (gcc --version) : egcs-2.91.66
+#
+# check tags
+# @uname:uname -srp:Linux 2.2.14-5.0 unknown
+# @cc:cc --version:egcs-2.91.66
+#
+#
+
+# ------------------------------------
+# General compilation flags
+# ------------------------------------
+
+#
+# MACHDEF : define machine and OS specific flags
+#
+
+MACHDEF = -DLX_TARGET_LINUX -DLITTLE_ENDIAN
+
+#
+# MATH_LIBS : machine specific math librairies
+#
+
+MATH_LIBS = -lm
+

src/prokov/lxpack/config/ports/ppc-darwin.conf

@@ -0,0 +1,32 @@
+#
+# $Id: ppc-darwin.conf 1825 2013-02-26 09:39:47Z viari $
+#
+# ppc-darwin.conf
+# configuration file for MacOS-X/Darwin 1.2 with native cc compiler
+# this file is included in Makefile
+#
+# system (uname -srp) : Darwin 1.2 powerpc
+# compiler (cc --version) : 2.7.2.1
+#
+# check tags
+# @uname:uname -srp:Darwin 1.2 powerpc
+# @cc:cc --version:2.7.2.1
+#
+#
+
+# ------------------------------------
+# General compilation flags
+# ------------------------------------
+
+#
+# MACHDEF : define machine and OS specific flags
+#
+
+MACHDEF = -DLX_TARGET_MACPPC -DBIG_ENDIAN
+
+#
+# CC : name of (ansi C) compiler to use
+#
+
+CC = cc -arch ppc
+

src/prokov/lxpack/config/ports/sparc-solaris.conf

@@ -0,0 +1,31 @@
+#
+# $Id: sparc-solaris.conf 1825 2013-02-26 09:39:47Z viari $
+#
+# sparc-solaris.conf
+# configuration file for sparc solaris with GNU gcc compiler
+# this file is included in Makefile
+#
+# system (uname -srp) : SunOS 5.8 sparc
+# compiler (gcc --version) : 2.95.2
+#
+# check tags
+# @uname:uname -srp:SunOS 5.8 sparc
+# @cc:cc --version:2.95.2
+#
+#
+
+# ------------------------------------
+# General compilation flags
+# ------------------------------------
+
+#
+# MACHDEF : define machine and OS specific flags
+#
+
+MACHDEF = -DLX_TARGET_SOLARIS -DBIG_ENDIAN
+
+#
+# MATH_LIBS : machine specific math librairies
+#
+
+MATH_LIBS = -lm

src/prokov/lxpack/config/ports/x86-mingw32.conf

@@ -0,0 +1,54 @@
+#
+# $Id: x86-mingw32.conf 1825 2013-02-26 09:39:47Z viari $
+#
+# x86-mingw32
+# configuration file for MinGW with GNU gcc compiler.
+#
+# this file is included in Makefile
+#
+#
+
+#
+# rename PORTNAME safely since MinGW produce pure win32 executables
+#                 without dll's
+#
+
+PORTNAME = x86-win32
+
+# ------------------------------------
+# General compilation flags
+# ------------------------------------
+
+#
+# CC_LIBS : additionnal machine specific $(CC) libraries
+#
+# libiberty is needed for some system extensions (like mkstemps)
+#
+
+CC_LIBS = -liberty
+
+#
+# MACHDEF : define machine and OS specific flags
+#
+# -DDLMALLOC : use dlmalloc instead of malloc (which does not have mallinfo)
+# -posix is a new replacement for several MinGW32 flags, including:
+#   -D__USE_MINGW_ANSI_STDIO : mingw gcc flag to recognize the C99 "%zu" format
+#
+
+MACHDEF = -posix -DLX_TARGET_WIN32 -DWIN_MINGW -DDLMALLOC -DLITTLE_ENDIAN
+
+#
+# MATH_LIBS : machine specific math librairies
+#
+
+MATH_LIBS = -lm
+
+# ------------------------------------
+# General system commands
+# ------------------------------------
+
+#
+# DIFF : diff command / should ignore cr on windows
+#
+
+DIFF = diff --strip-trailing-cr

src/prokov/lxpack/config/targets/debug.targ

@@ -0,0 +1,25 @@
+#
+# $Id: help.targ 1825 2013-02-26 09:39:47Z viari $
+#
+# debug.targ
+#
+# target to print debug information (dev. only)
+#
+# it defines the following targets:
+#
+# debug  : 
+#	 print debug
+#
+# it requires auto.conf
+#
+
+.PHONY: debug
+
+debug::
+	@echo "+ PORTNAME: $(PORTNAME)"
+	@echo "+ CFGPRT:   $(CFGPRT)"
+	@echo "+ CFGDIR:   $(CFGDIR)"
+	@echo "+ PRTDIR:   $(PRTDIR)"
+	@echo "+ MACHDEF:  $(MACHDEF)"
+
+

src/prokov/lxpack/config/targets/empty.targ

@@ -0,0 +1,24 @@
+#
+# $Id: $
+#
+# epty.targ
+#
+# default empty targets (defined as double colon rules)
+#
+#
+
+#
+# Rules
+#
+
+.PHONY: all test clean portclean help
+
+all::
+
+test::
+
+clean::
+
+portclean:: clean
+
+test::

src/prokov/lxpack/config/targets/help.targ

@@ -0,0 +1,23 @@
+#
+# $Id: help.targ 1825 2013-02-26 09:39:47Z viari $
+#
+# help.targ
+#
+# default target to print help
+#
+# it defines the following targets:
+#
+# help  : 
+#	 print help
+#
+
+.PHONY: help
+
+help::
+	@ echo "basic usage: make [<action>+]"
+	@ echo "valid <action>  :"
+	@ echo "  all	        : compile everything for current port [default target]"
+	@ echo "  clean	        : local cleanup"
+	@ echo "  portclean     : cleanup distribution for current port"
+	@ echo "  test	        : run tests on current port"
+	@ echo "  help	        : print this help"

src/prokov/lxpack/config/targets/lxbin.targ

@@ -0,0 +1,51 @@
+#
+# $Id: $
+#
+# lxbin.targ
+#
+# default make targets for standard lx binary
+#
+# you should define the 'PROGS' and 'OSRC' variables
+# and optionnaly 'LIBS' if binaries have to be linked with libraries
+#
+# note: if main source code for binary PROG is PROG.c, there is nothing to do,
+# else (e.g. if it involves several sources files) you should also add local
+# file dependencies. e.g under the form:
+#
+# mymain:	$(OBJ) mymain_base.c mymain_help.c
+#	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(LDLIBS)
+#
+#
+# 'auto.conf' should have been included
+#
+
+OBJ      = $(OSRC:.c=.o)
+
+INCDIR	 =	../include
+
+#
+# Rules
+#
+
+.PHONY: all prelib install test clean portclean
+
+all::	prelib $(PROGS) install
+	@echo "+++++++++++ binaries $(PROGS) done"
+
+prelib::
+	test -d $(PRTDIR) || mkdir $(PRTDIR)  # because some linker may complain
+	test -d $(LIBDIR) || mkdir $(LIBDIR)  # if -L$(LIBDIR) does not exist
+
+install::
+	test -d $(PRTDIR) || mkdir $(PRTDIR)
+	test -d $(BINDIR) || mkdir $(BINDIR)
+	-for f in $(PROGS) ; do \cp -f $$f $(BINDIR) ;  done
+
+test::
+
+clean::
+	-\rm -f *.o cvstatic* *% *.bak so_loc*
+	-\rm -f $(PROGS)
+
+portclean:: clean
+	-(! test -d $(BINDIR)) || (cd $(BINDIR) && \rm -f $(PROGS))

src/prokov/lxpack/config/targets/lxlib.targ

@@ -0,0 +1,43 @@
+#
+# $Id: $
+#
+# lxlib.targ
+#
+# default make targets for standard lx library
+#
+# you should define the 'LOCLIB' and 'OSRC' variables
+#
+# 'auto.conf' should have been included
+#
+
+OBJ      = $(OSRC:.c=.o)
+
+INCDIR	 =	../include
+
+#
+# Rules
+#
+
+.PHONY: all lib install test clean portclean
+
+all:: lib install
+	@echo "+++++++++++ library $(LOCLIB) done"
+
+lib:: $(OBJ)
+	$(AR) $(ARFLAGS) $(LOCLIB) $(OBJ)
+	$(RANLIB) $(LOCLIB)
+
+install::
+	test -d $(PRTDIR) || mkdir $(PRTDIR)
+	test -d $(LIBDIR) || mkdir $(LIBDIR)
+	\cp -f $(LOCLIB) $(LIBDIR)
+	$(RANLIB) $(LIBDIR)/$(LOCLIB)
+
+test::
+
+clean::
+	-\rm -f *.o cvstatic* *% *.bak so_loc*
+	-\rm -f $(LOCLIB)
+
+portclean:: clean
+	-(! test -d $(LIBDIR)) || (cd $(LIBDIR) && \rm -f $(LOCLIB))

src/prokov/lxpack/config/targets/package.targ

@@ -0,0 +1,48 @@
+#
+# $Id: package.targ 1825 2013-02-26 09:39:47Z viari $
+#
+# package.targ
+#
+# default make targets for standard package with configure
+#
+# you should define the 'PKG' variable
+# (and optionaly 'PKGTAR', 'PKGDIR')
+#
+
+PKGTAR ?= $(PKG).tgz
+
+PKGDIR ?= build.$(PORTNAME)
+
+PRTPATH = $(abspath $(PRTDIR))
+
+#
+# Rules
+#
+
+.PHONY: all clean test portclean pkg pkg.expand pkg.make pkg.install
+
+all:: pkg
+
+pkg.expand::
+	test -d $(PKGDIR) || mkdir $(PKGDIR)
+	test -f $(PKGDIR)/configure || $(TAR) zxf $(PKGTAR) -C $(PKGDIR) --strip-components 1
+
+pkg.make:: pkg.expand
+	test -f $(PKGDIR)/Makefile || (cd $(PKGDIR) && ./configure --prefix=$(PRTPATH))
+	$(MAKE) -C $(PKGDIR)
+
+pkg.install:: pkg.make
+	$(MAKE) -C $(PKGDIR) install
+
+pkg:: pkg.install
+	@echo "+++++++++++ package $(PKG) done"
+
+test::
+	(! test -d $(PKGDIR)) || $(MAKE) -C $(PKGDIR) test
+
+clean::
+	(! test -d $(PKGDIR)) || $(MAKE) -C $(PKGDIR) clean
+
+portclean::
+	(! test -d $(PKGDIR)) || $(MAKE) -C $(PKGDIR) distclean
+	(! test -d $(PKGDIR)) || \rm -r $(PKGDIR)

src/prokov/lxpack/config/targets/propagate.targ

@@ -0,0 +1,30 @@
+#
+# $Id: propagate.targ 1825 2013-02-26 09:39:47Z viari $
+#
+# propagate.targ
+#
+# default make targets for library containers
+#
+# you should define the 'DIRS' variable
+#
+# It will propagate 'MAKE <target>' to all
+# directories listed in DIRS
+#
+
+#
+# Rules
+#
+
+.PHONY: all _action $(DIRS)
+
+.DEFAULT:
+	$(MAKE) ACTION=$@ _action
+
+all::
+	$(MAKE) ACTION=all _action
+
+_action: $(DIRS)
+	@echo "$(ACTION) done"
+
+$(DIRS):
+	$(MAKE) -C $@ $(ACTION)

src/prokov/lxpack/include/fasta_io.h

@@ -0,0 +1,66 @@
+/* ---------------------------------------------------------------- */
+/* @file: fasta_io.h                                                */
+/* @desc: sequence IO in fasta format / include file                */
+/*                                                                  */
+/* @history:                                                        */
+/* @+       <Gloup> : Aug 92 : first version                        */
+/* @+       <Gloup> : Nov 95 : last revised version                 */
+/* ---------------------------------------------------------------- */
+
+#ifndef _H_fasta_io
+
+#define _H_fasta_io
+
+/* ==================================================== */
+/* Constantes                                           */
+/* ==================================================== */
+
+#define FASTA_NAMLEN  64        /* max length of seq. name       */
+#define FASTA_COMLEN  512       /* max length of seq. comment    */
+
+#define FASTA_CHAR_PER_LINE 50  /* # of chars per line in output */
+
+/* ==================================================== */
+/* Macros standards                                     */
+/* ==================================================== */
+
+#ifndef NEW
+#define NEW(typ)                (typ*)malloc(sizeof(typ)) 
+#define NEWN(typ, dim)          (typ*)malloc((unsigned)(dim) * sizeof(typ))
+#define REALLOC(typ, ptr, dim)  (typ*)realloc((void *) (ptr), (unsigned long)(dim) * sizeof(typ))
+#define FREE(ptr)               free(ptr)
+#endif
+
+/* ==================================================== */
+/* Structures de donnees                                */
+/* ==================================================== */
+
+typedef struct {                        /* -- Sequence ---------------- */
+        int     ok;                     /* error flag                   */
+        long    length,                 /* longueur                     */
+                offset,                 /* offset                       */
+                bufsize;                /* size of current seq buffer   */
+        char    name[FASTA_NAMLEN],     /* nom                          */
+                comment[FASTA_COMLEN],  /* commentaire                  */
+                *seq;                   /* sequence                     */
+} FastaSequence, *FastaSequencePtr;
+
+/* ==================================================== */
+/*  Prototypes                                          */
+/* ==================================================== */
+
+                                        /* libfasta.c   */
+
+char             *GetFastaName      ( char *buffer );
+char             *GetFastaComment   ( char *buffer );
+
+FastaSequencePtr NewFastaSequence   ( void );
+FastaSequencePtr FreeFastaSequence  ( FastaSequencePtr seq );
+
+int              ReadFastaSequence  ( FILE *streamin, FastaSequencePtr seq );
+int              GetFastaSequence   ( FILE *streamin, FastaSequencePtr seq );
+void             WriteFastaSequence ( FILE *streamou, FastaSequencePtr seq , int char_per_line );
+
+void             RewindFastaDB      ( FILE *streamin );
+
+#endif

src/prokov/lxpack/include/libkov.h

@@ -0,0 +1,126 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: libkov.h                                                  */
+/* @desc: libkov - include file                                     */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* ---------------------------------------------------------------- */
+
+#ifndef _H_libkov
+
+#define _H_libkov
+
+#define K_MAX      8            /* kuple maxi                   */
+#define POW_KMAX   65536        /*  = 4^KMAX                    */
+#define POW_KMIN   16384        /*  = 4^(KMAX-1)                */
+
+#define MAX_WIN    4096         /* taille maxi fenetre          */
+
+                                /* --- default values ----      */
+#define KUP_DFT    3            /* default kuple                */
+#define PCODANT    80           /* proba codant A Priori (%)    */
+#define WIN_WIDTH  120          /* window width                 */
+#define WIN_STEP   30           /* window step                  */
+#define MIN_CDS    120          /* minimun cds length           */
+#define THRESH_CDS 40           /* proba cds min (%)            */
+#define MATNAME    "Matrix"     /* nom fichier de sortie        */
+
+#define START_DFT  "/ATG/GTG/TTG/"
+#define STOP_DFT   "/TAA/TAG/TGA/"
+
+#define VERSION    "v1.2"       /* version number               */
+#define VERSIZE    16           /* header version size          */
+
+                                /* env. variable for Matrix dir */
+#define PROKOV_MAT_ENV "PROKOV_MATDIR"
+
+/* ==================================================== */
+/* structures                                           */
+/* ==================================================== */
+
+typedef struct {
+        int     kupleC, kupleN;
+        int     powkC, powkN;
+
+        int     occpos[3][POW_KMAX],    /* occurences   */
+                occneg[3][POW_KMAX],
+                occnc[POW_KMAX];
+
+        float   probpos[3][POW_KMAX],   /* probas cond. */
+                probneg[3][POW_KMAX],
+                probnc[POW_KMAX];
+                
+        float   pinipos[3][POW_KMIN],   /* probas init. */
+                pinineg[3][POW_KMIN],
+                pininc[POW_KMIN];
+
+        char    version[VERSIZE];
+} MarkovMatrix;
+
+typedef struct {
+        float   probpos[3],
+                probneg[3], 
+                probnc;
+} ProbaArray;
+
+        
+/* ==================================================== */
+/* macros                                               */
+/* ==================================================== */
+
+#define MIN(x, y) (((x) < (y)) ? (x) :  (y))
+#define MAX(x, y) (((x) > (y)) ? (x) :  (y))
+#define ABS(x)    (((x) > 0)   ? (x) : -(x))
+
+#ifndef NEW
+#define NEW(typ)                (typ*)malloc(sizeof(typ)) 
+#define NEWN(typ, dim)          (typ*)malloc((unsigned)(dim) * sizeof(typ))
+#define REALLOC(typ, ptr, dim)  (typ*)realloc((void *) (ptr), (unsigned)(dim) * sizeof(typ))
+#define FREE(ptr)               free(ptr)
+#endif
+
+/* ==================================================== */
+/* prototypes                                           */
+/* ==================================================== */
+
+                        /* libkov_util.c                */
+
+int     Erreur           (char *msg, int stat);
+char    *Complement      (char *str);
+char    *Reverse         (char *str);
+char    *Upper           (char *str);
+char    *RNAtoDNA        (char *str);
+int     Valeur           (char s);
+int     ValeurComplement (int valeur);
+int     Pow4             (int n);
+int     Codage           (char *seq, int kuple);
+int     CodageComplement (int index, int kuple);
+int     SuiteCodage      (char *seq, int prec, int kuple);
+int     FindCodon        (char *seq, int lenseq, char *codons, int from, int to);
+int     InternalFrame   (int dframe, int direct, int seqlen);
+
+void    ComputeNegOccurences(int occneg[3][POW_KMAX],
+                             int occpos[3][POW_KMAX], int kuple);
+
+
+                        /* libkov_io.c                  */
+
+int     AssignToStdin   (char *filename);
+FILE    *OpenFile       (char *filename, char *mode);
+char    *MatrixPathName (char *shortname);
+
+int     WriteMatrix     (MarkovMatrix *mat, int isAscii, FILE *stream);
+int     ReadMatrix      (MarkovMatrix *mat, int isAscii, FILE *stream);
+
+                        /* libkov_proba.c               */
+
+void    ProbaCond   (MarkovMatrix *mat);
+                  
+void    ProbaMarkov (char *seq, int seqlen, MarkovMatrix *mat,
+                     ProbaArray *win);
+                     
+void    ProbaBayes  (ProbaArray *win, float prior, ProbaArray *bay);
+
+#endif

src/prokov/lxpack/src/.gdb_history

@@ -0,0 +1,198 @@
+run prokov_learn )h
+run prokov_learn -h
+exit
+quit
+run -h
+where
+list
+print argn
+exit
+quit
+run -h
+exit
+quit
+run -h
+quit
+run 
+run -h
+where
+list
+exit
+quit
+list
+file
+exit
+quit
+run -h
+list
+step
+quit
+run bacil.learn
+where
+list
+stop sWriteMatrixHeaderBinary
+run
+where
+bye
+exit
+quit
+run bacil.learn
+where
+list
+stop WriteMatrix
+run
+list
+list
+list
+where
+list 470
+stop 473
+run
+stop
+stop at 472
+run
+list
+list 473
+stop in WriteMatrix
+status
+help
+sjhow
+show
+show breaks
+help show
+help stop
+help
+help breakpoints
+break WriteMatrix
+run
+step
+stepi
+step
+step
+list
+print mat->version
+print mat
+print *mat
+up
+list
+bye
+quit
+break at 473
+break 473
+run bacil.learn
+print mat
+stepi
+list
+stepi
+stepi
+where
+step
+where
+step
+list
+where
+print mat
+up
+print mat
+print &mat
+down
+print mat
+print *mat
+up
+print &mat
+print *(&mat)
+down
+print mat
+quit
+run bacil.learn
+list
+where
+break in sWriteMatrixHeaderBinary
+break in WriteMatrix
+quit
+run bacil.learn
+where
+break in WriteMatrix
+break WriteMatrix
+run
+print mat
+print *mat
+up
+print mat
+print &mat
+print *(&mat)
+list
+print aflag
+print filou
+print &mat
+down
+quit
+stop at 437
+beak at 437
+break at 437
+break 437
+run bacil.learn
+print pmat
+print *pmat
+print pmat
+break WriteMatrix
+cont
+print isAscii
+print mat
+print *mat
+print &mat
+quit
+run bacilo.learn
+run bacil.learn
+where
+up
+list
+print mat
+print *mat
+up
+print pmat
+list
+up
+print pmat
+print *pmat
+down
+where
+print mat
+print *mat
+quit
+run bacil.learn
+where
+print mat
+list
+quit
+run bacil.learn
+where
+up
+print mat
+print mat->version
+print *mat
+whatis mat
+sizeof mat
+quit
+run bacil.learn
+where
+up
+up
+up
+print mat
+up
+print pmat
+quit
+run -m toto.mat
+up
+up
+print mat
+print *mat
+quit
+run bacil.learn
+where
+quit
+run bacil.learn
+where
+exit
+quit

src/prokov/lxpack/src/.make.state

@@ -0,0 +1 @@
+.MAKE_VERSION:	VERSION-1.0

src/prokov/lxpack/src/Makefile

@@ -0,0 +1,49 @@
+# ---------------------------------------------------------------
+# @file: Makefile
+# @desc: makefile prokov
+#
+# @history:
+# @+	    <Gloup> : Sun Oct 31 1999 : Created
+# @+   	    <Gloup> : Dec 00 : HelixWare port
+# @+	    <Gloup> : Mar 01 : Corrected <if> bug
+#
+# @note: should be processed with gnu compatible make
+# @note: helixware_compatible
+#
+# @end:
+# ---------------------------------------------------------------
+#
+
+include ../config/auto.conf
+
+PROGS = prokov_learn prokov_curve \
+	    prokov_score prokov_cds   \
+	    prokov_orf
+
+OSRC = fasta_io.c	    \
+       libkov_util.c	\
+	   libkov_io.c	    \
+	   libkov_proba.c
+
+include $(CFGDIR)targets/lxbin.targ
+include $(CFGDIR)targets/help.targ
+
+#
+# file dependencies
+#
+
+prokov_learn : $(OBJ) prokov_learn.c
+	$(CC) $(CFLAGS) -o $@ $@.c $(OBJ) $(LDFLAGS) $(LDLIBS)
+
+prokov_curve : $(OBJ) prokov_curve.c
+	$(CC) $(CFLAGS) -o $@ $@.c $(OBJ) $(LDFLAGS) $(LDLIBS)
+
+prokov_score : $(OBJ) prokov_score.c
+	$(CC) $(CFLAGS) -o $@ $@.c $(OBJ) $(LDFLAGS) $(LDLIBS)
+
+prokov_cds : $(OBJ) prokov_cds.c
+	$(CC) $(CFLAGS) -o $@ $@.c $(OBJ) $(LDFLAGS) $(LDLIBS)
+
+prokov_orf : $(OBJ) prokov_orf.c
+	$(CC) $(CFLAGS) -o $@ $@.c $(OBJ) $(LDFLAGS) $(LDLIBS)
+

src/prokov/lxpack/src/TODO

@@ -0,0 +1,17 @@
+>DONE libkov_proba.c : 
+
+>DONE pnc  = FLOG10(1.0 - prior);
+
+malloc
+
+>DONE correction path absolu prokov_curve/cds/score
+
+>DONE correction phase prokov_cds
+
+>DONE correction matrices
+
+> DONE LITTLE_ENDIAN ?
+
+> DONE v1.2
+
+> do_test

src/prokov/lxpack/src/fasta_io.c

@@ -0,0 +1,372 @@
+/* ---------------------------------------------------------------- */
+/* @file: fasta_io.c                                                */
+/* @desc: sequence IO in fasta format                               */
+/*                                                                  */
+/* @history:                                                        */
+/* @+       <Gloup> : Aug 92 : first version                        */
+/* @+       <Gloup> : Nov 95 : last revised version                 */
+/* ---------------------------------------------------------------- */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "fasta_io.h"
+
+#define SECURE   0      /* 1 : secure copy ; 0 : quickest copy  */
+
+#define READ_NEXT 0
+#define PUSH_BACK 1
+
+#define SERIAL    1
+#define INDEXED   0
+
+#ifdef MAC_OS_C
+#define LINE_FEED '\r'
+#else
+#define LINE_FEED '\n'
+#endif
+
+static int sRetained = 0;
+
+/* -------------------------------------------- */
+/* @static: lecture bufferisee                  */
+/* -------------------------------------------- */
+static char * sNextIOBuffer(FILE *streamin, int retain, int serial)
+{
+        char  *buf, *end;
+        int   reused;
+        
+        static char sBuffer[BUFSIZ];    /* BUFSIZ in <stdio.h>  */
+        
+        reused = (retain || sRetained) && serial;
+
+        sRetained = retain;
+
+        buf = (   reused 
+                ? sBuffer 
+                : fgets(sBuffer, sizeof(sBuffer), streamin));           
+
+        if (! buf)                /* end of file            */
+            return NULL;
+
+        end = buf + strlen(buf) - 1;
+
+        if (*end == LINE_FEED)    /* remove trailing \n     */
+           *end = '\000';
+
+        return (  *buf || reused
+                ? buf
+                : sNextIOBuffer(streamin, retain, serial));
+}
+
+#if SECURE
+/* -------------------------------------------- */
+/* compte le nombre de caracteres alpha dans    */
+/* un buffer                                    */
+/* -------------------------------------------- */
+static long sCountAlpha(char *buf)
+{
+        long count;
+        
+        for (count = 0 ; *buf ; buf++)
+            if (isalpha(*buf))
+                count++;
+        
+        return count;
+}
+#endif
+
+#if SECURE
+/* -------------------------------------------- */
+/* copy only alpha chars from s2 to s1          */
+/* -------------------------------------------- */
+static char *sStrcpyAlpha(char *s1, char *s2)
+{
+        for( ; *s2 ; s2++)
+            if (isalpha(*s2))
+                *s1++ = *s2;
+
+        *s1 = '\000';
+
+        return s1;
+}
+#endif
+
+/* -------------------------------------------- */
+/* skip to next space in buffer                 */
+/* -------------------------------------------- */
+static char *sNextSpace(char *buffer)
+{
+        for (; *buffer ; buffer++)
+           if (isspace(*buffer))
+                return buffer;
+        
+        return NULL;
+}
+
+/* -------------------------------------------- */
+/* returns sequence name (FASTA)                */
+/* -------------------------------------------- */
+char *GetFastaName(char *buffer)
+{
+        char c[2];
+        static char name[FASTA_NAMLEN];
+
+        *c = buffer[FASTA_NAMLEN];
+         buffer[FASTA_NAMLEN] = '\000';
+        
+        if (sscanf(buffer + 1, "%s", name) != 1)
+            (void) strcpy(name, "<no Name>");
+
+        buffer[FASTA_NAMLEN] = *c;
+         
+        return name;
+}
+
+/* -------------------------------------------- */
+/* returns sequence comment (FASTA)             */
+/* -------------------------------------------- */
+char *GetFastaComment(char *buffer)
+{
+        char   *space;
+        static char comment[FASTA_COMLEN];
+
+        buffer[FASTA_COMLEN] = '\000';
+        
+        space = sNextSpace(buffer);
+        
+        (void) strcpy(comment, (space ? space + 1 : "\000"));
+
+        return comment;
+}
+
+/* -------------------------------------------- */
+/* liberation d'une sequence                    */
+/* -------------------------------------------- */
+FastaSequencePtr FreeFastaSequence(FastaSequencePtr seq)
+{
+        if (seq) {
+            if (seq->seq)  FREE(seq->seq);
+            FREE(seq);
+        }
+
+        return NULL;
+}
+        
+/* -------------------------------------------- */
+/* allocation d'une sequence                    */
+/* -------------------------------------------- */
+FastaSequencePtr NewFastaSequence()
+{
+        FastaSequencePtr seq;
+        
+        if (! (seq = NEW(FastaSequence)))
+            return NULL;
+           
+        seq->length   = 0;
+        seq->offset   = -1;
+
+        if (! (seq->seq = NEWN(char,  BUFSIZ)))
+            return FreeFastaSequence(seq);
+
+        seq->bufsize = BUFSIZ;
+
+        *(seq->name)    = '\000';
+        *(seq->comment) = '\000';
+
+        seq->ok = 1;
+        
+        return seq;
+}
+
+/* -------------------------------------------- */
+/* lecture/redimensionnement d'une sequence au  */
+/* format Fasta                                 */
+/* <Lecture Serie>                              */
+/* returns : 0 -> last sequence                 */
+/*           1 -> more to read                  */
+/*           <but> you must check seq->ok       */
+/*           that may be '0' (memory error)     */
+/* -------------------------------------------- */
+int ReadFastaSequence(FILE *streamin, FastaSequencePtr seq)
+{
+        long    readlen, buflen;
+        char    *buffer, *tbuf;
+
+        seq->ok = 0;                             /* assume error         */
+
+        buflen = seq->length = 0; 
+        
+        seq->offset = ftell(streamin);
+
+        buffer = sNextIOBuffer(streamin, READ_NEXT, SERIAL);
+
+        if (! (buffer && (*buffer == '>')))     /* sync error           */
+            return 0;                           /* last sequence        */
+        
+        if (seq->offset)
+            seq->offset -= (strlen(buffer) + 1);
+
+        (void) strcpy(seq->name,    GetFastaName(buffer));
+        
+        (void) strcpy(seq->comment, GetFastaComment(buffer));
+        
+        while (buffer = sNextIOBuffer(streamin, READ_NEXT, SERIAL)) {
+
+            if (*buffer == '>') {
+                (void) sNextIOBuffer(streamin, PUSH_BACK, SERIAL); /* push it back */
+                break;
+            }
+
+#if SECURE          
+            readlen = sCountAlpha(buffer);
+#else
+            readlen = strlen(buffer);
+#endif
+        
+            buflen +=  readlen;
+   
+            if (buflen >= seq->bufsize) {
+            
+                if (! (tbuf = REALLOC(char, seq->seq, 2 * buflen + 1)))
+                   return 1;  /* but seq->ok is 0  */
+
+                seq->seq = tbuf;
+                
+                seq->bufsize = 2 * buflen + 1;
+                
+            }           
+#if SECURE
+            sStrcpyAlpha(seq->seq + seq->length, buffer);
+#else
+            (void) memcpy(seq->seq + seq->length, buffer, readlen);
+#endif
+        
+            seq->length = buflen;
+        
+        }
+
+        seq->seq[seq->length] = '\000';
+
+        return (seq->ok = 1);
+}
+
+/* -------------------------------------------- */
+/* lecture/redimensionnement d'une sequence au  */
+/* format Fasta                                 */
+/* <Lecture Indexee>                            */
+/* returns : 0 -> memory error                  */
+/*           1 -> read ok                       */
+/* -------------------------------------------- */
+int GetFastaSequence(FILE *streamin, FastaSequencePtr seq)
+{
+        long    readlen, buflen;
+        char    *buffer, *tbuf;
+
+        seq->ok = 0;                            /* assume error         */
+
+        buflen = seq->length = 0; 
+        
+        (void) fseek(streamin, seq->offset, SEEK_SET);
+
+        buffer = sNextIOBuffer(streamin, READ_NEXT, INDEXED);
+
+        if (! (buffer && (*buffer == '>')))     /* sync error           */
+            return 0;                           /* last sequence        */
+        
+        if (seq->offset)
+            seq->offset -= (strlen(buffer) + 1);
+
+        (void) strcpy(seq->name,    GetFastaName(buffer));
+        
+        (void) strcpy(seq->comment, GetFastaComment(buffer));
+        
+        while (buffer = sNextIOBuffer(streamin, READ_NEXT, INDEXED)) {
+
+            if (*buffer == '>')
+                break;
+
+#if SECURE          
+            readlen = sCountAlpha(buffer);
+#else
+            readlen = strlen(buffer);
+#endif
+        
+            buflen +=  readlen;
+   
+            if (buflen >= seq->bufsize) {
+            
+                if (! (tbuf = REALLOC(char, seq->seq, 2 * buflen + 1)))
+                   return 0;                 
+
+                seq->seq = tbuf;
+                
+                seq->bufsize = 2 * buflen + 1;
+                
+            }           
+#if SECURE
+            sStrcpyAlpha(seq->seq + seq->length, buffer);
+#else
+            (void) memcpy(seq->seq + seq->length, buffer, readlen);
+#endif
+        
+            seq->length = buflen;
+        
+        }
+
+        seq->seq[seq->length] = '\000';
+
+        return (seq->ok = 1);
+}
+
+/* -------------------------------------------- */
+/* ecriture d'une sequence au format Fasta      */
+/* -------------------------------------------- */
+void WriteFastaSequence(FILE *streamou, FastaSequencePtr seq, 
+                        int char_per_line)
+{
+        long  i, nlines, rest;
+        char *buf, *end, tempo;
+
+        (void) fputc('>', streamou);
+        (void) fputs((*(seq->name)    ? seq->name    : "no_name"), streamou);
+        (void) fputc(' ', streamou);
+        (void) fputs((*(seq->comment) ? seq->comment : "\000"), streamou);
+        (void) fputc(LINE_FEED, streamou);
+
+        nlines = seq->length / char_per_line;
+
+        buf = seq->seq;
+
+        for (i = 0 ; i < nlines ; i++) {
+            end = buf + char_per_line;
+            tempo = *end;
+            *end = '\000';
+            (void) fputs(buf, streamou);
+            (void) fputc(LINE_FEED , streamou);
+            *end = tempo;
+            buf += char_per_line;
+        }
+
+        if ((rest = (seq->length % char_per_line)) != 0) {
+           end = buf + rest;
+           tempo = *end;
+           *end = '\000';
+           (void) fputs(buf, streamou);
+           (void) fputc(LINE_FEED , streamou);
+           *end = tempo;
+        }
+}
+
+/* -------------------------------------------- */
+/* rewind db file                               */
+/* -------------------------------------------- */
+void RewindFastaDB(FILE *streamin)
+{
+    sRetained = 0;   /* forget previous buffer  */
+    
+    if (streamin)
+        rewind(streamin);
+}

src/prokov/lxpack/src/libkov_io.c

@@ -0,0 +1,465 @@
+/* ---------------------------------------------------------------- */
+/* @file: libkov_io.c                                               */
+/* @desc: Prokov Input/Output                                       */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <ABI> : Aug 99 : first version                              */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* @+   <Gloup> : Dec 00 : HelixWare port - V1.2                    */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "libkov.h"
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX 1024
+#endif
+
+#ifdef LITTLE_ENDIAN
+#define ENDIAN(n) sEndian(n)
+#else
+#define ENDIAN(n) n
+#endif
+
+#define LONG_OUTPUT 0   /* should be 0 for compatibility with V1.2 and earlier */
+
+/* ============================================ */
+/* Machine binary conversions                   */
+/* ============================================ */
+
+/* -------------------------------------------- */
+/* static                                       */
+/* convert int  little <-> big endian           */
+/* binary files are coded in big-endian format  */
+/* -------------------------------------------- */
+int sEndian (int n)
+{
+    union {
+       int  integer;
+       unsigned char byte[4];
+    } convert;
+    
+    unsigned char tempo;
+
+    convert.integer = n;
+    
+    tempo           = convert.byte[0];
+    convert.byte[0] = convert.byte[3];
+    convert.byte[3] = tempo;
+    tempo           = convert.byte[1];
+    convert.byte[1] = convert.byte[2];
+    convert.byte[2] = tempo;
+    
+    return convert.integer;
+}
+
+/* -------------------------------------------- */
+/* static                                       */
+/* convert array src to dst big endian          */
+/* -------------------------------------------- */
+static void sArrayEndian(int dst[], int src[], int taille)
+{
+    int i;
+    
+    for (i = 0 ; i < taille ; i++)
+        dst[i] = ENDIAN(src[i]);
+}
+
+/* ============================================ */
+/* File Utilities                               */
+/* ============================================ */
+
+/* -------------------------------------------- */
+/* open a file and assign it to stdin           */
+/* -------------------------------------------- */
+
+int AssignToStdin(char *filename)
+{
+    char buffer[256];
+        
+    if (! freopen(filename, "r", stdin)) {
+        (void) sprintf(buffer, "cant open file %s to read", filename);
+        return Erreur(buffer, 0);
+    }
+
+    return 1;
+}
+
+/* -------------------------------------------- */
+/* open a file                                  */
+/* -------------------------------------------- */
+
+FILE *OpenFile(char *filename, char *mode)
+{
+    FILE *stream;
+    char buffer[256];
+        
+    if (! (stream = fopen(filename, mode))) {
+        (void) sprintf(buffer, "cant open file %s in mode %s",
+                        filename, mode);
+        (void) Erreur(buffer, 0);
+    }
+
+    return stream;
+}
+
+/* -------------------------------------------- */
+/* get fullpathname for matrix file             */
+/* -------------------------------------------- */
+
+char * MatrixPathName(char *shortname) {
+
+    char *env;
+    
+    static char sPath[FILENAME_MAX];
+
+    env = getenv(PROKOV_MAT_ENV);
+    
+    if (env)
+        (void) strcat(strcpy(sPath, env), "/");
+    else
+        (void) strcpy(sPath, "");
+
+    return strcat(sPath, shortname);
+}
+
+
+/* ============================================ */
+/* Matrix io                                    */
+/* ============================================ */
+
+/* -------------------------------------------- */
+/* static                                       */
+/* ensure count of occurences is not 0          */
+/* -------------------------------------------- */
+static void sCheckOccurences(int occ[], int taille)
+{
+    int i;
+    
+    for (i = 0 ; i < taille ; i++) {
+        if (occ[i] == 0)
+            occ[i] = 1;
+    }
+}
+
+/* -------------------------------------------- */
+/* write Header - Ascii format                  */
+/* -------------------------------------------- */
+
+static int sWriteMatrixHeaderAscii(MarkovMatrix *mat, FILE *stream)
+{
+    int ok;
+    
+    ok = fprintf(stream, "%s %d %d %d %d\n",
+                 mat->version, mat->kupleC, mat->kupleN,
+                 mat->powkC, mat->powkN);
+
+    return (ok > 0);
+}
+
+/* -------------------------------------------- */
+/* write Header - Binary format                 */
+/* -------------------------------------------- */
+
+static int sWriteMatrixHeaderBinary(MarkovMatrix *mat, FILE *stream)
+{
+    int  ok, nb, val;
+    char buffer[VERSIZE];
+
+    (void) memset(buffer, 0, VERSIZE);
+    (void) strcpy(buffer, mat->version);  /* version : 16 bytes */    
+    nb = fwrite(buffer, sizeof(char), VERSIZE, stream);
+    ok = (nb == VERSIZE); 
+
+    val = ENDIAN(mat->kupleC);            /* kupleC : 4 bytes   */
+    nb = fwrite(&val, sizeof(int), 1, stream);
+    ok = ok && (nb == 1); 
+
+    val = ENDIAN(mat->kupleN);            /* kupleN : 4 bytes   */
+    nb = fwrite(&val, sizeof(int), 1, stream);
+    ok = ok && (nb == 1); 
+
+    val = ENDIAN(mat->powkC);             /* powkC : 4 bytes    */
+    nb = fwrite(&val, sizeof(int), 1, stream);
+    ok = ok && (nb == 1); 
+
+    val = ENDIAN(mat->powkN);            /* powkN : 4 bytes     */
+    nb = fwrite(&val, sizeof(int), 1, stream);
+    ok = ok && (nb == 1); 
+
+    return ok;
+}
+
+
+/* -------------------------------------------- */
+/* write Matrix Body - Ascii format             */
+/* -------------------------------------------- */
+
+static int sWriteMatrixBodyAscii(MarkovMatrix *mat, FILE *stream)
+{
+    int i, phase, ok;
+    
+    ok = 1;
+    
+    for (i = 0 ; i < mat->powkC ; i++) {
+       
+       for (phase = 0 ; phase < 3 ; phase++) {
+           ok = ok && (fprintf(stream, "%d\t", mat->occpos[phase][i]) > 0);
+
+#if LONG_OUTPUT
+           ok = ok && (fprintf(stream, "%d\t", mat->occneg[phase][i]) > 0);
+#endif
+       }
+
+       (void) fprintf(stream, "\n");
+    }
+
+    for (i = 0 ; i < mat->powkN ; i++)
+        ok = ok && (fprintf(stream, "%d\n", mat->occnc[i]) > 0);
+
+   return ok;
+}
+
+/* -------------------------------------------- */
+/* write Matrix Body - Binary format            */
+/* -------------------------------------------- */
+
+static int sWriteMatrixBodyBinary(MarkovMatrix *mat, FILE *stream)
+{
+    int phase, nb;
+    int buffer[POW_KMAX];
+    
+    nb    = 0;
+    
+    for (phase = 0 ; phase < 3 ; phase++) {
+        sArrayEndian(buffer, mat->occpos[phase], mat->powkC);
+        nb += fwrite(buffer, sizeof(int), mat->powkC, stream);
+
+#if LONG_OUTPUT
+        sArrayEndian(buffer, mat->occneg[phase], mat->powkC);
+        nb += fwrite(buffer, sizeof(int), mat->powkC, stream);
+#endif
+    }
+
+    sArrayEndian(buffer, mat->occnc, mat->powkN);
+    nb += fwrite(buffer, sizeof(int), mat->powkN, stream);
+
+#if LONG_OUTPUT
+    return (nb == ((mat->powkC * 6) + mat->powkN));
+#else
+    return (nb == ((mat->powkC * 3) + mat->powkN));
+#endif
+}
+
+/* -------------------------------------------- */
+/* read Header - Ascii format                   */
+/* -------------------------------------------- */
+
+static int sReadMatrixHeaderAscii(MarkovMatrix *mat, FILE *stream)
+{
+    int  ok;
+    
+    ok = fscanf(stream, "%s%d%d%d%d\n",
+                mat->version, &(mat->kupleC), &(mat->kupleN), 
+                              &(mat->powkC),  &(mat->powkN));
+
+    ok =    (ok > 0) 
+         && (mat->kupleC <= K_MAX) && (mat->kupleN <= K_MAX)
+         && (mat->kupleC > 0)      && (mat->kupleN > 0)
+         && (mat->powkC == Pow4(mat->kupleC)) 
+         && (mat->powkN == Pow4(mat->kupleN))
+         && (! strcmp(mat->version, VERSION));
+         
+    return ok;
+}
+
+/* -------------------------------------------- */
+/* read Header - Binary format                  */
+/* -------------------------------------------- */
+
+static int sReadMatrixHeaderBinary(MarkovMatrix *mat, FILE *stream)
+{
+    int  ok, nb, val;
+
+                                        /* version : 16 bytes   */    
+    nb = fread(mat->version, sizeof(char), VERSIZE, stream);
+    ok =    (nb == VERSIZE)
+         && (! strcmp(mat->version, VERSION));
+
+                                        /* kupleC : 4 bytes     */
+    nb = fread(&val, sizeof(int), 1, stream);
+    mat->kupleC = ENDIAN(val);
+    ok =    ok 
+         && (nb == 1)
+         && (mat->kupleC <= K_MAX)
+         && (mat->kupleC > 0);
+
+                                        /* kupleN : 4 bytes     */
+    nb = fread(&val, sizeof(int), 1, stream);
+    mat->kupleN = ENDIAN(val);
+    ok =    ok 
+         && (nb == 1)
+         && (mat->kupleN <= K_MAX)
+         && (mat->kupleN > 0);
+
+                                        /* powkC : 4 bytes      */
+    nb = fread(&val, sizeof(int), 1, stream);
+    mat->powkC = ENDIAN(val);
+    ok =    ok 
+         && (mat->powkC = Pow4(mat->kupleC));
+
+                                        /* powkC : 4 bytes      */
+    nb = fread(&val, sizeof(int), 1, stream);
+    mat->powkN = ENDIAN(val);
+    ok =    ok 
+         && (mat->powkN = Pow4(mat->kupleN));
+
+    return ok;
+}
+
+/* -------------------------------------------- */
+/* read Matrix Body - Ascii format              */
+/* -------------------------------------------- */
+
+static int sReadMatrixBodyAscii(MarkovMatrix *mat, FILE *stream)
+{
+    int i, phase, ok;
+    
+    ok = 1;
+    
+    for (i = 0 ; i < mat->powkC ; i++) {
+       
+       for (phase = 0 ; phase < 3 ; phase++) {
+           ok = ok && (fscanf(stream, "%d\t", &(mat->occpos[phase][i])) > 0);
+
+#if LONG_OUTPUT
+           ok = ok && (fscanf(stream, "%d\t", &(mat->occneg[phase][i])) > 0);
+#endif
+       }
+    }
+
+#if ! LONG_OUTPUT
+    ComputeNegOccurences(mat->occneg, mat->occpos, mat->kupleC);
+#endif
+   
+    for (i = 0 ; i < mat->powkN ; i++)
+       ok = ok && (fscanf(stream, "%d\n", &(mat->occnc[i])) > 0);
+   
+   if (ok) {
+        for (phase = 0 ; phase < 3 ; phase++)
+            sCheckOccurences(mat->occpos[phase], mat->powkC);
+        for (phase = 0 ; phase < 3 ; phase++)
+            sCheckOccurences(mat->occneg[phase], mat->powkC);
+        sCheckOccurences(mat->occnc, mat->powkN);
+   }
+   
+   return ok;
+}
+
+/* -------------------------------------------- */
+/* read Matrix Body - Binary format             */
+/* -------------------------------------------- */
+
+static int sReadMatrixBodyBinary(MarkovMatrix *mat, FILE *stream)
+{
+    int phase, nb, ok;
+    int buffer[POW_KMAX];
+    
+    nb = 0;
+    
+    for (phase = 0 ; phase < 3 ; phase++) {
+        nb += fread(buffer, sizeof(int), mat->powkC, stream);
+        sArrayEndian(mat->occpos[phase], buffer, mat->powkC);
+
+#if LONG_OUTPUT
+        nb += fread(buffer, sizeof(int), mat->powkC, stream);
+        sArrayEndian(mat->occneg[phase], buffer, mat->powkC);
+#endif
+    }
+
+#if ! LONG_OUTPUT
+    ComputeNegOccurences(mat->occneg, mat->occpos, mat->kupleC);
+#endif
+
+    nb += fread(buffer, sizeof(int), mat->powkN, stream);
+    sArrayEndian(mat->occnc, buffer, mat->powkN);
+
+#if LONG_OUTPUT
+    ok = (nb == ((mat->powkC * 6) + mat->powkN));
+#else
+    ok = (nb == ((mat->powkC * 3) + mat->powkN));
+#endif
+    
+    if (ok) {
+        for (phase = 0 ; phase < 3 ; phase++)
+            sCheckOccurences(mat->occpos[phase], mat->powkC);
+        for (phase = 0 ; phase < 3 ; phase++)
+            sCheckOccurences(mat->occneg[phase], mat->powkC);
+        sCheckOccurences(mat->occnc, mat->powkN);
+    }
+
+    return ok;
+}
+
+/* -------------------------------------------- */
+/* write/read Matrix - Interface calls          */
+/* -------------------------------------------- */
+
+int WriteMatrix(MarkovMatrix *mat, int isAscii, FILE *stream)
+{
+
+    if (isAscii) {
+       if (! sWriteMatrixHeaderAscii(mat, stream)) {
+          Erreur("Invalid ascii matrix header", 0);
+          return 0;
+       }
+       if (! sWriteMatrixBodyAscii(mat, stream)) {
+          Erreur("Invalid ascii matrix body", 0);
+          return 0;
+       }
+    }
+    else {
+       if (! sWriteMatrixHeaderBinary(mat, stream)) {
+          Erreur("Invalid binary matrix header", 0);
+          return 0;
+       }
+       if (! sWriteMatrixBodyBinary(mat, stream)) {
+          Erreur("Invalid binary matrix body", 0);
+          return 0;
+       }
+    }
+
+    return 1;
+}
+
+int ReadMatrix(MarkovMatrix *mat, int isAscii, FILE *stream)
+{
+
+    if (isAscii) {
+       if (! sReadMatrixHeaderAscii(mat, stream)) {
+          Erreur("Invalid ascii matrix header", 0);
+          return 0;
+       }
+       if (! sReadMatrixBodyAscii(mat, stream)) {
+          Erreur("Invalid ascii matrix body", 0);
+          return 0;
+       }
+    }
+    else {
+       if (! sReadMatrixHeaderBinary(mat, stream)) {
+          Erreur("Invalid binary matrix header", 0);
+          return 0;
+       }
+       if (! sReadMatrixBodyBinary(mat, stream)) {
+          Erreur("Invalid binary matrix body", 0);
+          return 0;
+       }
+    }
+
+    return 1;
+}
+

src/prokov/lxpack/src/libkov_proba.c

@@ -0,0 +1,179 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: libkov_proba.c                                            */
+/* @desc: prokov probabilities computation                          */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+
+#include "libkov.h"
+
+
+#ifdef SGI
+#define FLOG10(x) flog10(x)     /* in math library on sgi */
+#define FPOW(x,y) powf(x,y)     /*                        */
+#else
+#define FLOG10(x) (float)log10((double)(x))
+#define FPOW(x,y) (float)pow((double)(x), (double)(y)) 
+#endif
+
+
+/* ---------------------------------------------------- */
+/* calcul des probas conditionnelles et des probas      */
+/* initiales a partir du tableau des occurences         */
+/*                                                      */
+/* note: on stocke en fait le log10 des probas          */
+/* ---------------------------------------------------- */
+static void sProbaCond (int kuple, int occ[POW_KMAX],
+                float proba[POW_KMAX], float pinit[POW_KMIN])
+{
+    int i, j, powk, somme, count;
+
+    powk = Pow4(kuple);
+    
+    /* ------------------------------------------------- */     
+    /* calcul somme des occurences                       */
+    /* ------------------------------------------------- */     
+
+    somme = 0;
+
+    for (j = 0 ; j < powk ; j++)
+        somme += occ[j];
+
+    /* ------------------------------------------------- */     
+    /* calcul des probas initiales et des probas         */
+    /* conditionnelles                                   */
+    /* ------------------------------------------------- */     
+    /* les occurence sont rangees dans l'ordre           */
+    /* x1...xk-1A, x1...xk-1C, x1...xk-1G, x1...xk-1T    */
+    /* donc les frequences des x1...xk-1 correspondent   */
+    /* aux sommes 4 par 4 des elements de occ[]          */
+    /* ------------------------------------------------- */     
+
+    for (j = 0 ; j < powk ; j += 4) {
+                                     /* -1- probas initiales      */
+        count = 0;                   /* frequence de x1...xk-1    */
+        for (i = 0 ; i < 4 ; i++)
+            count += occ[j+i];
+
+        pinit[j/4] = FLOG10((float) count / (float) somme);
+
+                                     /* -2- probas conditionelles */
+        for (i = 0 ; i < 4 ; i++)
+            proba[j+i] = FLOG10((float) occ[j+i] / (float) count);
+    
+    }
+}
+
+/* ---------------------------------------------------- */
+/* calcul des probas conditionnelles et des probas      */
+/* initiales a partir du tableau des occurences         */
+/*                                                      */
+/* API interface call                                   */
+/* ---------------------------------------------------- */
+
+void ProbaCond(MarkovMatrix *mat)
+{
+    int i;
+    
+    for (i = 0 ; i < 3 ; i++) {
+        sProbaCond(mat->kupleC, mat->occpos[i], mat->probpos[i],
+                   mat->pinipos[i]);
+        sProbaCond(mat->kupleC, mat->occneg[i], mat->probneg[i],
+                   mat->pinineg[i]);
+    }
+    
+    sProbaCond(mat->kupleN, mat->occnc, mat->probnc, mat->pininc);
+}
+
+/* ---------------------------------------------------- */
+/* calcule la probabilite de la chaine seq[0:winmax-1]  */
+/* P(window/Codi)                                       */
+/*                                                      */
+/* ---------------------------------------------------- */
+void ProbaMarkov (char *seq, int seqlen, MarkovMatrix *mat,
+                  ProbaArray *win)
+{
+   int i, phase, phi, val; 
+
+   for (phase = 0 ; phase < 3 ; phase++ ) {
+                                                /* -------------------- */
+       val = Codage(seq, mat->kupleC-1);        /* k-1 uple initial     */
+       win->probpos[phase] = mat->pinipos[phase][val];
+       win->probneg[phase] = mat->pinineg[phase][val];
+
+       for (i = 0 ; i < seqlen ; i++ ) {        /* autres kuples        */
+
+           val = (  (i == 0) 
+                  ? Codage(seq, mat->kupleC)
+                  : SuiteCodage(seq + i, val, mat->kupleC));
+                    
+           phi = (phase+i)%3;
+           win->probpos[phase] += mat->probpos[phi][val]; /* probas en log */
+           win->probneg[phase] += mat->probneg[phi][val];
+       } 
+   }
+
+   val = Codage(seq, mat->kupleN-1);
+   win->probnc = mat->pininc[val];
+   
+   for (i = 0 ; i < seqlen ; i++) {          
+       val = (  (i == 0)
+              ? Codage(seq, mat->kupleN)
+              : SuiteCodage(seq + i, val, mat->kupleN));
+
+       win->probnc += mat->probnc[val];
+   }
+}
+
+/* ---------------------------------------------------- */
+/* applique la formule d'inversion de Bayes pour        */
+/* calculer P(Codi/wind)                                */
+/* ---------------------------------------------------- */
+void ProbaBayes(ProbaArray *win, float prior,
+                ProbaArray *bay)
+{
+   int   i, j;
+   float somme, pcod, pnc;
+   
+   pcod = FLOG10(prior/6.);             /* proba codant APRIORI     */
+   pnc  = FLOG10(1.0 - prior);          /* proba non-codant APRIORI */
+
+   for (i = 0 ; i < 3 ; i++) {
+       somme = 0.;
+       for (j = 0 ; j < 3 ; j++) {
+           somme += FPOW(10., win->probpos[j] - win->probpos[i]);
+           somme += FPOW(10., win->probneg[j] - win->probpos[i]);
+       }
+       somme += FPOW(10., win->probnc + pnc - win->probpos[i] - pcod);
+       bay->probpos[i] = 1. / somme;
+   }
+
+   for (i = 0 ; i < 3 ; i++) {
+       somme = 0.;
+       for (j = 0 ; j < 3 ; j++) {
+           somme += FPOW(10., win->probpos[j] - win->probneg[i]);
+           somme += FPOW(10., win->probneg[j] - win->probneg[i]);
+       }
+       somme += FPOW(10., win->probnc + pnc - win->probneg[i] - pcod);
+       bay->probneg[i] = 1. / somme;
+   }
+
+   somme = 0.;
+   for (j = 0 ; j < 3 ; j++) {
+           somme += FPOW(10., win->probpos[j] + pcod - win->probnc - pnc);
+           somme += FPOW(10., win->probneg[j] + pcod - win->probnc - pnc);
+   }
+   somme += 1.;
+ 
+   bay->probnc = 1. / somme;
+}
+

src/prokov/lxpack/src/libkov_util.c

@@ -0,0 +1,291 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: libkov_util.c                                             */
+/* @desc: utilitaires prokov                                        */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* @+   <Gloup> : Dec 00 : HelixWare port                           */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#include "fasta_io.h"
+#include "libkov.h"
+
+#define BIO_FRAME       1       /* set to 1 for biological frames */
+
+/* -------------------------------------------- */
+/* error reporting                              */
+/* -------------------------------------------- */
+int Erreur(char *msg, int stat)
+{
+    (void) fprintf(stderr, "*Error* [%d] %s\n", stat, msg);
+
+    (void) fflush(stderr);
+        
+    if (stat > 0)
+       exit(stat);
+
+    return stat;
+}
+
+/* ---------------------------------------------------- */
+/* complemente la chaine str                            */
+/* ---------------------------------------------------- */
+char *Complement(char *str)
+{
+    char *s;
+    
+    for (s = str ; *s ; s++) {
+
+        switch(*s) {
+            case 'A' : *s = 'T'; break;  
+            case 'T' : *s = 'A'; break;
+            case 'C' : *s = 'G'; break;
+            case 'G' : *s = 'C'; break;
+        }
+
+     }
+
+     return str;   
+}
+
+/* ---------------------------------------------------- */
+/* renverse la chaine str                               */
+/* ---------------------------------------------------- */
+char *Reverse(char *str)
+{
+    char *sb, *se, c;
+
+    if (! str)
+        return str;
+            
+    sb = str;
+    se = str + strlen(str) - 1;
+
+    while(sb <= se) {
+        c    = *sb;
+        *sb++ = *se;
+        *se-- = c;
+    }
+
+    return str;
+}
+
+/* ---------------------------------------------------- */
+/* uppercase la chaine str                              */
+/* ---------------------------------------------------- */
+char *Upper(char *str)
+{
+    char *s;
+    
+    for (s = str ; *s ; s++) 
+        if (islower(*s))
+           *s = toupper(*s);
+           
+    return str;
+}
+
+/* ---------------------------------------------------- */
+/* convert RNA to DNA                                   */
+/* ---------------------------------------------------- */
+char *RNAtoDNA(char *str)
+{
+    char *s;
+    
+    for (s = str ; *s ; s++) 
+        if (*s == 'U')
+           *s = 'T';
+           
+    return str;
+}
+
+/* ---------------------------------------------------- */
+/*  valeur des symboles                                 */
+/* A=0; C=1; G=2; T=3 ; Other = 0                       */
+/* ---------------------------------------------------- */
+int Valeur(char s)
+{
+    switch (s) {
+        case 'A' : return 0;
+        case 'C' : return 1;
+        case 'G' : return 2;
+        case 'T' : return 3;
+    }
+
+    return 0; /* ? use A if unknown */
+}
+
+/* ---------------------------------------------------- */
+/*  valeur du symbol compl<70>mentaire                     */
+/* ---------------------------------------------------- */
+int ValeurComplement (int valeur)
+{
+    switch (valeur) {
+        case 0 : return 3; /* A -> T */ 
+        case 1 : return 2; /* C -> G */
+        case 2 : return 1; /* G -> C */
+        case 3 : return 0; /* T -> A */
+    }
+
+     return 0; /* ? use A if unknown */ 
+}
+
+/* ---------------------------------------------------- */
+/* calcule 4^n                                          */
+/* tabulated version                                    */
+/* ---------------------------------------------------- */
+int Pow4(int n)
+{
+    int i, pow;
+
+    static int sInited = 0;
+    static int sTable[K_MAX];
+
+    if (sInited)
+       return sTable[n];
+       
+    pow = 1;
+
+    for (i = 0 ; i < K_MAX ; i++) {
+        sTable[i] = pow;
+        pow *= 4;
+    }
+    
+    sInited = 1;
+    
+    return sTable[n];
+}
+
+/* ---------------------------------------------------- */
+/* hash coding d'un kuple (pour 4 symboles)             */
+/* ---------------------------------------------------- */
+int Codage(char *seq, int kuple)
+{
+    int i, index;
+
+    index = 0;
+    for (i = 0 ; i < kuple ; i++)
+        index = (index << 2) | Valeur(seq[i]);
+
+    return index;
+}
+
+/* ---------------------------------------------------- */
+/* hash coding du complement-inverse du k-uple de       */
+/* hashcode index                                       */
+/* ---------------------------------------------------- */
+int CodageComplement(int index, int kuple)
+{
+    int i, cind;
+
+    cind = 0;
+    for (i = 0 ; i < kuple ; i++) {
+        cind = (cind << 2) |  ValeurComplement(index & 0x03);
+        index = (index >> 2);
+    }
+
+    return cind;
+}
+
+/* ---------------------------------------------------- */
+/* hash coding d'un kuple (pour 4 symboles) lorsque le  */
+/* kuple precedent a deja ete calcule                   */
+/* ---------------------------------------------------- */
+int SuiteCodage(char *seq, int prec, int kuple)
+{
+    int new, mask;
+
+    mask = Pow4(kuple) - 1; /* 0x7fffffff >> (32 - (2*k)) */
+
+    new = ((prec << 2) | Valeur(seq[kuple-1])) & mask;
+
+    return new;
+}
+
+/* ---------------------------------------------------- */
+/* recherche du codon suivant dans une liste            */
+/* ---------------------------------------------------- */
+int FindCodon(char *seq, int lenseq, char *codons, int from, int to)
+{
+    int len;
+    char save;
+    char *sf, *st, *ss, *found;
+
+    len = lenseq - 1;
+    
+    from = MIN(MAX(0, from), len);
+    to   = MIN(MAX(from, to), len);
+
+    /* round to multiple of 3 */
+
+    len = ((to - from + 1) / 3) * 3; 
+    to  = from + len - 1;
+         
+    sf = seq + from;
+    st = seq + to;
+
+    for (ss = sf ; ss <= st ; ss += 3) {
+        save  = ss[3];
+        ss[3] = '\000';
+        found = strstr(codons, ss);
+        ss[3] = save;
+        if (found) 
+           return ((int) (ss - sf)) + from;
+    }
+
+    return -1;
+}
+
+/* ---------------------------------------------------- */
+/* calcul du frame de calcul correspondant au frame de  */
+/* display dframe  - convention bio -                   */
+/* pour la 'convention genemark' mettre BIO_FRAME a 0   */
+/* note: les frames sont numerotes 0, 1, 2              */
+/* ---------------------------------------------------- */
+int InternalFrame(int dframe, int direct, int seqlen)
+{
+    int iframe;
+    
+    if (direct) {                               /* ---- direct strand  ---- */
+       iframe = (3 - dframe) % 3;                       /* math convertion  */
+    }
+    else {                                      /* ---- reverse strand ---- */
+
+#if BIO_FRAME
+       iframe = (5 - dframe + ((seqlen+1) % 3)) % 3;    /* bio convention   */
+#else
+       iframe = dframe;                                 /* GM convention    */
+#endif
+       iframe = (3 - iframe) % 3;                       /* math convertion  */
+    }
+
+    return iframe;
+}
+
+/* ---------------------------------------------------- */
+/* calcul des occurences en phase negative a partir     */
+/* des occurences en phase positive                     */
+/* ---------------------------------------------------- */
+
+void ComputeNegOccurences(int occneg[3][POW_KMAX],
+                          int occpos[3][POW_KMAX], int kuple)
+{
+    int  i, j, powk, phase, phaseinv;
+
+    powk = Pow4(kuple);
+   
+    for (phase = 0 ; phase < 3 ; phase ++) {
+        phaseinv = (3 - (kuple + phase) % 3 ) % 3; 
+        for (i = 0 ; i < powk ; i++) {
+            j = CodageComplement(i, kuple);
+            occneg[phase][i] = occpos[phaseinv][j];
+        }
+    }
+}
+

src/prokov/lxpack/src/prokov_cds.c

@@ -0,0 +1,501 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: prokov_cds.c                                              */
+/* @desc: prokov - phase detection : recherche cds                  */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* @+   <Gloup> : Nov 99 : added Markov model for non-coding        */
+/* @+   <Gloup> : Dec 00 : HelixWare port - V1.2                    */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifdef HAS_GETOPT_H
+#include HAS_GETOPT_H
+#endif
+
+#include "fasta_io.h"
+#include "libkov.h"
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX 1024
+#endif
+
+#ifndef BUFSIZ
+#define BUFSIZ 4096
+#endif
+
+#define BIOFRAME 1
+
+/* -------------------------------------------- */
+/* getopt globals                               */
+/* -------------------------------------------- */
+
+        extern char     *optarg;
+        extern int      optind;
+
+/* ----------------------------------------------- */
+/* printout help                                   */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stdout, 
+
+static void sPrintHelp()
+{
+    PP  "------------------------------------------     \n");
+    PP  " Prokov Version %s\n", VERSION);
+    PP  "------------------------------------------     \n");
+    PP  "synopsis :                                     \n");
+    PP  "  Markov/Bayes based gene prediction           \n");
+    PP  "  * detection phase - CDSs searching *         \n");
+    PP  "                                               \n");
+    PP  "usage: prokov_cds [options] seqfile            \n");
+    PP  "------------------------------------------     \n");
+    PP  "options:                                       \n");
+    PP  "                                               \n");      
+    PP  "-a : read matrix in [A]scii format             \n");
+    PP  "        default: read in binary format         \n");
+    PP  "                                               \n");      
+    PP  "-h : this [H]elp                               \n");
+    PP  "                                               \n");      
+    PP  "-l nn : minimun cds [L]ength                   \n");
+    PP  "        default: -l %d\n", MIN_CDS);
+    PP  "                                               \n");      
+    PP  "-m name : [M]atrix filename                    \n");
+    PP  "        default: -m %s\n", MATNAME);
+    PP  "                                               \n");      
+    PP  "-o : [O]utput sequence data too (fasta format) \n");
+    PP  "        default: off (short output)            \n");
+    PP  "                                               \n");      
+    PP  "-p nn : use nn %% as prior coding probability  \n");
+    PP  "        default: -p %d\n", PCODANT);
+    PP  "                                               \n");      
+    PP  "-s string : use string as Starts               \n");
+    PP  "        string has the form \"/XYZ/.../XYZ/\"  \n");
+    PP  "        default: -S %s\n", START_DFT);
+    PP  "                                               \n");      
+    PP  "-S string : use string as Stops                \n");
+    PP  "        string has the form \"/XYZ/.../XYZ/\"  \n");
+    PP  "        default: -S %s\n", STOP_DFT);
+    PP  "                                               \n");      
+    PP  "-t nn : cds probability [T]hreshold  (%%)      \n");
+    PP  "        default: -l %d\n", THRESH_CDS);
+    PP  "                                               \n");      
+    PP  "-v : set [V]erbose mode                        \n");
+    PP  "                                               \n");      
+    PP  "-w nn : start [W]alk                           \n");
+    PP  "        expressed as %% of cds size            \n");           
+    PP  "        default: walk off                      \n");
+    PP  "                                               \n");      
+    PP  "-W nn : start [W]alk                           \n");
+    PP  "        expressed as number of bases           \n");           
+    PP  "        default: walk off                      \n");
+    PP  "                                               \n");      
+    PP  "------------------------------------------     \n");
+    PP  " seqfile : file containing one sequence        \n");
+    PP  "             in Fasta format                   \n");
+    PP  "------------------------------------------     \n");
+}
+
+#undef PP
+
+/* ----------------------------------------------- */
+/* printout usage and exit                         */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stderr, 
+
+static int sExitUsage(int stat)
+{
+    PP  "usage: prokov_cds [options] seqfile    \n");
+    PP  "type \"prokov_cds -h\" for help        \n");
+
+    if (stat)
+        exit(stat);
+            
+    return stat;
+}
+
+#undef PP
+
+/* ----------------------------------------------- */
+/* score a single window in phase +1               */
+/* ----------------------------------------------- */
+static float sScoreWindow(char *seq, int lenseq, MarkovMatrix *mat,
+                          int prior)
+{
+    ProbaArray   win, bay;
+
+    ProbaMarkov(seq, lenseq, mat, &win);
+    ProbaBayes(&win, (float) prior / 100., &bay);
+    
+    return bay.probpos[0];      /* phase +1 */
+}
+
+/* ----------------------------------------------- */
+/* output fragment of sequence (fasta format)      */
+/* ----------------------------------------------- */
+void sOutputSequence(FastaSequence *seq, int posa,
+                     int poss, int strand, 
+                     char *name, char *comment)
+{
+    char save;
+        
+    static FastaSequence sSeq;
+
+    (void) strcpy(sSeq.name, name);
+    (void) strcpy(sSeq.comment, comment);
+
+    sSeq.seq = seq->seq + posa;
+
+    poss += 3;
+
+    save = seq->seq[poss];
+    seq->seq[poss] = '\000';
+    sSeq.length = poss - posa;
+
+    WriteFastaSequence(stdout, &sSeq, FASTA_CHAR_PER_LINE);
+
+    seq->seq[poss] = save;
+}
+
+/* ----------------------------------------------- */
+/* print a CDS                                     */
+/* ----------------------------------------------- */
+
+void sPrintCds(FastaSequence *seq, int strand, int phase,
+               int posa, int poss, int poso, float score,
+               int outflag)
+{
+    int from, to, ori, frame;
+    char bufname[BUFSIZ], bufcom[BUFSIZ];
+    
+
+    from = ((strand > 0) ? posa + 1 : seq->length - poss - 2);
+    to   = ((strand > 0) ? poss + 3 : seq->length - posa);
+
+    ori  = ((strand > 0) ? poso + 1 : seq->length - poso);
+
+#if BIOFRAME
+    frame = ((from - 1) % 3 ) + 1;
+#else
+    frame = phase;
+#endif
+
+    (void) sprintf(bufname, "%s_CDS_%d_%d_%s", seq->name,
+                               from, to, ((strand > 0) ? "D" : "C"));  
+
+    (void) sprintf(bufcom, "%d %d %1s%d %.3f %s %d",
+                   from, to, 
+                   ((strand > 0) ? "+" : "-"), frame,
+                   score,
+                   ((poso == posa) ? "max" : "walk"),
+                   ((poso == posa) ? 0 : ori));
+
+     if (outflag)       /* long output */    
+        sOutputSequence(seq, posa, poss, strand, bufname, bufcom);
+     else               /* short output */
+        (void) printf("%s %s\n", bufname, bufcom);
+}
+
+
+/* ----------------------------------------------- */
+/* process cds's in single phase                   */
+/* ----------------------------------------------- */
+static void sProcessSequence(FastaSequence *seq, 
+                int strand, int phase, int mincds, int outflag,
+                int dowalk, int walk, int prior, int thresh,
+                char *starts, char *stops,
+                MarkovMatrix *mat)
+{
+    int posa, posb, poso, poss, lencds, awalk;
+    float scort, scora, scorb;
+
+
+    scort = (float) thresh / 100.;      /* threshold      */
+    
+    posa = phase;                       /* start on phase */
+    
+    awalk = (  dowalk 
+             ? ((walk > 0) ? walk : ABS(walk) * seq->length / 100)
+             : 0);
+
+    while ((posa = FindCodon(seq->seq, seq->length, starts, posa, seq->length - 1)) >= 0)  {
+
+        poss = FindCodon(seq->seq, seq->length, stops, posa, seq->length - 1);
+
+        if (poss < 0)
+           break;               /* no more stop */
+                
+        lencds = poss - posa;
+             
+        if (lencds < mincds) {
+           posa = poss + 3;     /* try next start */
+           continue;            
+        }
+        
+        scora = sScoreWindow(seq->seq + posa, lencds, mat, prior);
+
+        /* try to walk around start */
+        
+        poso = posa;
+        
+        if (dowalk) {
+        
+            posb = posa + 3;
+            
+            while ((posb = FindCodon(seq->seq, seq->length, starts, posb, seq->length - 1)) >= 0) {
+            
+                if ((posb - posa) > awalk)
+                   break;       /* too far away */
+
+                lencds = poss - posb;
+            
+                if (lencds < mincds)
+                   break;       /* too short    */
+            
+                scorb = sScoreWindow(seq->seq + posb, lencds, mat, prior);
+        
+                if (scorb > scora) {  /* best start */
+                   posa = posb;
+                   scora = scorb;
+                }
+                
+                posb += 3;
+
+             }
+        }
+
+        if (scora >= scort) {
+           sPrintCds(seq, strand, phase, posa, poss, poso, scora, outflag); 
+           posa = poss + 3;
+        }
+        else {
+           posa += 3;
+        }
+    }
+}
+
+/* ---------------------------------------------------- */
+/*                PROGRAMME PRINCIPAL                   */
+/* ---------------------------------------------------- */
+
+int main(int argn, char *argv[]) {
+
+    /* Declarations */
+
+    int   phase, walk, mincds, prior, thresh;
+    int   carg, errflag, aflag, vflag, wflag, oflag; 
+
+    MarkovMatrix *pmat;
+  
+    FastaSequence *seq;
+    
+    FILE  *filin;
+
+    char  stops[256], starts[256];
+    
+    char  inname[FILENAME_MAX];
+
+    /* ------------------------ */
+    /* allocate matrix          */
+    /* (avoid stack overflow    */
+    /*  on some machines)       */
+    /* ------------------------ */
+
+    if (! (pmat = NEW(MarkovMatrix)))
+        Erreur("Not enough memory", 10);
+
+    /* ------------------------ */
+    /* lecture des arguments    */
+    /* ------------------------ */
+
+    /* ------------------------ */
+    /* valeurs par defaut       */
+    
+    errflag = 0;
+ 
+    aflag  = 0;         /* binary input         */
+    vflag  = 0;         /* not verbose          */
+    wflag  = 0;         /* no walk              */
+    oflag  = 0;         /* short output         */
+    
+    prior  = PCODANT;   /* 80% coding           */
+    walk   = 0;         /* walk off             */
+    mincds = MIN_CDS;   /* min cds length       */
+    thresh = THRESH_CDS;/* 40                   */
+    
+    (void) strcpy(inname, MATNAME);
+    (void) strcpy(starts, START_DFT);
+    (void) strcpy(stops,  STOP_DFT);
+
+    while ((carg = getopt(argn, argv, "ahl:m:op:s:S:t:vw:W:")) != -1) {
+            
+        switch(carg) {
+
+            case 'a' :              /* ascii mode   */
+                aflag = 1;
+                break;
+
+            case 'h' :              /* help         */
+                sPrintHelp();
+                exit(0);
+                break;
+
+            case 'l' :              /* min cds      */
+                if (sscanf(optarg, "%d", &mincds) != 1)
+                   errflag++;
+                break;
+
+            case 'm' :              /* matrix name  */
+                (void) strcpy(inname, optarg);
+                break;
+
+            case 'o' :              /* long output    */
+                oflag = 1;
+                break;
+
+            case 'p' :              /* prior        */
+                if (sscanf(optarg, "%d", &prior) != 1)
+                   errflag++;
+                break;
+
+            case 's' :              /* starts       */
+                (void) strcpy(starts, optarg);
+                break;
+
+            case 'S' :              /* stops        */
+                (void) strcpy(stops, optarg);
+                break;
+
+            case 't' :              /* threshold    */
+                if (sscanf(optarg, "%d", &thresh) != 1)
+                   errflag++;
+                break;
+
+            case 'v' :              /* verbose      */
+                vflag = 1;
+                break;
+
+            case 'w' :              /* walk         */
+                if (sscanf(optarg, "%d", &walk) != 1)
+                   errflag++;
+                wflag = 1;
+                walk = -walk;      /* means '%'     */
+                break;
+
+            case 'W' :              /* walk         */
+                if (sscanf(optarg, "%d", &walk) != 1)
+                   errflag++;
+                wflag = 1;
+                break;
+
+            case '?' :              /* misusage     */
+                errflag++;
+        }
+    }
+    
+    /* ------------------------ */
+    /* may remain 1 argument    */
+
+    if ((argn - optind) > 1)
+        errflag++;
+    else if ((argn - optind) == 1) {
+        if (! AssignToStdin(argv[optind]))
+           errflag++;
+    }
+
+    /* ------------------------ */
+    /* check arguments          */
+    
+    if ((prior <= 0) || (prior >= 100)) {
+        Erreur("invalid prior value", 0);
+        errflag++;
+    }
+
+    if ((thresh < 0) || (thresh > 100)) {
+        Erreur("invalid thresh value", 0);
+        errflag++;
+    }
+
+    if (mincds <= 0) {
+        Erreur("invalid mincds value", 0);
+        errflag++;
+    }
+
+    if ((wflag) && (walk < 0) && (ABS(walk) > 100)) {
+       Erreur("invalid walk value", 0);
+       errflag++;
+    }
+       
+    if (! (filin = OpenFile(MatrixPathName(inname), (aflag ? "r" : "rb"))))
+        errflag++;
+
+    /* ------------------------ */
+    /* exit on usage error      */
+
+    if (errflag) 
+        (void) sExitUsage(1);
+
+    /* -------------------------------- */
+    /* lecture matrice                  */
+    /* -------------------------------- */
+
+    if (! ReadMatrix(pmat, aflag, filin))
+       exit(3);
+
+    (void) fclose(filin);
+
+    /* -------------------------------- */
+    /* calcul des proba de transition   */
+    /* et probas initiales              */
+    /* -------------------------------- */
+    
+    ProbaCond(pmat);   
+
+    /* -------------------------------- */
+    /* lecture sequence                 */
+    /* -------------------------------- */
+
+    seq = NewFastaSequence();
+    ReadFastaSequence(stdin, seq);
+    (void) RNAtoDNA(Upper(seq->seq));
+
+    /* -------------------------------- */
+    /* recherche des cds dans chaque    */
+    /* phase positive                   */
+    /* -------------------------------- */
+    
+    for (phase = 0 ; phase < 3 ; phase++)
+        sProcessSequence(seq, 1, phase, mincds, oflag, wflag,
+                         walk, prior, thresh, starts, stops,
+                         pmat);
+
+    /* -------------------------------- */
+    /* recherche des cds dans chaque    */
+    /* phase negative                   */
+    /* -------------------------------- */
+
+    Complement(Reverse(seq->seq));
+
+    for (phase = 0 ; phase < 3 ; phase++)
+        sProcessSequence(seq, -1, phase, mincds, oflag, wflag,
+                         walk, prior, thresh, starts, stops,
+                         pmat);
+
+    /* -------------------------------- */
+    /* fin du programme                 */
+    /* -------------------------------- */
+
+    FREE(pmat);
+
+    FreeFastaSequence(seq);
+    
+    return 0 ;
+}
+

src/prokov/lxpack/src/prokov_curve.c

@@ -0,0 +1,286 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: prokov_curve.c                                            */
+/* @desc: prokov - phase detection : trace courbes                  */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* @+   <Gloup> : Nov 99 : added Markov model for non-coding        */
+/* @+   <Gloup> : Dec 00 : HelixWare port - V1.2                    */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifdef HAS_GETOPT_H
+#include HAS_GETOPT_H
+#endif
+
+#include "fasta_io.h"
+#include "libkov.h"
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX 1024
+#endif
+
+/* -------------------------------------------- */
+/* getopt globals                               */
+/* -------------------------------------------- */
+
+        extern char     *optarg;
+        extern int      optind;
+
+/* ----------------------------------------------- */
+/* printout help                                   */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stdout, 
+
+static void sPrintHelp()
+{
+    PP  "------------------------------------------     \n");
+    PP  " Prokov Version %s\n", VERSION);
+    PP  "------------------------------------------     \n");
+    PP  "synopsis :                                     \n");
+    PP  "  Markov/Bayes based gene prediction           \n");
+    PP  "  * detection phase - curve *                  \n");
+    PP  "                                               \n");
+    PP  "usage: prokov_curve [options] seqfile          \n");
+    PP  "------------------------------------------     \n");
+    PP  "options:                                       \n");
+    PP  "                                               \n");      
+    PP  "-a : read matrix in [A]scii format             \n");
+    PP  "        default: read in binary format         \n");
+    PP  "                                               \n");      
+    PP  "-h : this [H]elp                               \n");
+    PP  "                                               \n");      
+    PP  "-m name : [M]atrix filename                    \n");
+    PP  "        default: -m %s\n", MATNAME);
+    PP  "                                               \n");      
+    PP  "-p nn : use nn %% as prior coding probability  \n");
+    PP  "        default: -p %d\n", PCODANT);
+    PP  "                                               \n");      
+    PP  "-s nn : window [S]tep                          \n");
+    PP  "        default: -s %d\n", WIN_STEP);
+    PP  "                                               \n");      
+    PP  "-v : set [V]erbose mode                        \n");
+    PP  "                                               \n");      
+    PP  "-w nn : window [W]idth                         \n");
+    PP  "        default: -w %d\n", WIN_WIDTH);
+    PP  "                                               \n");      
+    PP  "------------------------------------------     \n");
+    PP  " seqfile : file containing one sequence        \n");
+    PP  "             in Fasta format                   \n");
+    PP  "------------------------------------------     \n");
+}
+
+#undef PP
+
+/* ----------------------------------------------- */
+/* printout usage and exit                         */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stderr, 
+
+static int sExitUsage(int stat)
+{
+    PP  "usage: prokov_curve [options] seqfile  \n");
+    PP  "type \"prokov_curve -h\" for help      \n");
+
+    if (stat)
+        exit(stat);
+            
+    return stat;
+}
+
+#undef PP
+
+/* ---------------------------------------------------- */
+/*                PROGRAMME PRINCIPAL                   */
+/* ---------------------------------------------------- */
+
+int main(int argn, char *argv[]) {
+
+    /* Declarations */
+
+    int   i, pos;
+    int   winmax, width, step, prior;
+    int   carg, errflag, aflag, vflag; 
+
+    MarkovMatrix *pmat;
+    ProbaArray   win, baye;
+    
+    FastaSequence *seq;
+    
+    FILE  *filin;
+    
+    char  inname[FILENAME_MAX];
+
+    /* ------------------------ */
+    /* allocate matrix          */
+    /* (avoid stack overflow    */
+    /*  on some machines)       */
+    /* ------------------------ */
+
+    if (! (pmat = NEW(MarkovMatrix)))
+        Erreur("Not enough memory", 10);
+
+    /* ------------------------ */
+    /* lecture des arguments    */
+    /* ------------------------ */
+
+    /* ------------------------ */
+    /* valeurs par defaut       */
+    
+    errflag = 0;
+ 
+    aflag  = 0;         /* binary input         */
+    vflag  = 0;         /* not verbose          */
+    
+    prior  = PCODANT;   /* 80% coding           */
+    width  = WIN_WIDTH; /* window width         */
+    step   = WIN_STEP;  /* window step          */
+
+    (void) strcpy(inname, MATNAME);
+
+    while ((carg = getopt(argn, argv, "ahm:p:s:vw:")) != -1) {
+            
+        switch(carg) {
+
+            case 'a' :              /* ascii mode   */
+                aflag = 1;
+                break;
+
+            case 'h' :              /* help         */
+                sPrintHelp();
+                exit(0);
+                break;
+
+            case 'm' :              /* matrix name  */
+                (void) strcpy(inname, optarg);
+                break;
+
+            case 'p' :              /* prior        */
+                if (sscanf(optarg, "%d", &prior) != 1)
+                   errflag++;
+                break;
+
+            case 's' :              /* step         */
+                if (sscanf(optarg, "%d", &step) != 1)
+                   errflag++;
+                break;
+
+            case 'v' :              /* verbose      */
+                vflag = 1;
+                break;
+
+            case 'w' :              /* width        */
+                if (sscanf(optarg, "%d", &width) != 1)
+                   errflag++;
+                break;
+
+            case '?' :              /* misusage     */
+                errflag++;
+        }
+    }
+    
+    /* ------------------------ */
+    /* may remain 1 argument    */
+
+    if ((argn - optind) > 1)
+        errflag++;
+    else if ((argn - optind) == 1) {
+        if (! AssignToStdin(argv[optind]))
+           errflag++;
+    }
+
+    /* ------------------------ */
+    /* check arguments          */
+    
+    if ((prior <= 0) || (prior >= 100)) {
+        Erreur("invalid prior value", 0);
+        errflag++;
+    }
+
+    if (width <= 0) {
+        Erreur("invalid width value", 0);
+        errflag++;
+    }
+
+    if (step <= 0) {
+        Erreur("invalid step value", 0);
+        errflag++;
+    }
+
+    if (! (filin = OpenFile(MatrixPathName(inname), (aflag ? "r" : "rb"))))
+        errflag++;
+
+    /* ------------------------ */
+    /* exit on usage error      */
+
+    if (errflag) 
+        (void) sExitUsage(1);
+
+    /* -------------------------------- */
+    /* lecture matrice                  */
+    /* -------------------------------- */
+
+    if (! ReadMatrix(pmat, aflag, filin))
+       exit(3);
+
+    (void) fclose(filin);
+
+    /* -------------------------------- */
+    /* calcul des proba de transition   */
+    /* et probas initiales              */
+    /* -------------------------------- */
+    
+    ProbaCond(pmat);   
+
+    /* -------------------------------- */
+    /* lecture sequence                 */
+    /* -------------------------------- */
+
+    seq = NewFastaSequence();
+    ReadFastaSequence(stdin, seq);
+    (void) RNAtoDNA(Upper(seq->seq));
+
+    /* -------------------------------- */
+    /* boucle deplacement fenetre       */
+    /* et ecriture des probas dans les  */
+    /* 7 phases                         */
+    /* -------------------------------- */
+
+    winmax = width - MAX(pmat->kupleC, pmat->kupleN) + 1;
+
+    for (pos = 0 ; pos < seq->length - width + 1 ; pos += step) {
+
+       ProbaMarkov(seq->seq + pos, winmax, pmat, &win);
+
+       ProbaBayes(&win, (float) prior / 100., &baye);
+
+       (void) printf("%6d\t", pos + width/2 + 1);
+       
+       for (i = 0 ; i < 3 ; i++)
+          (void) printf("%.3f\t", baye.probpos[InternalFrame(i, 1, seq->length)]);
+
+       for (i = 0 ; i < 3 ; i++)
+          (void) printf("%.3f\t", baye.probneg[InternalFrame(i, 0, seq->length)]);
+
+       (void) printf("%.3f\n", baye.probnc);
+    }
+
+    /* -------------------------------- */
+    /* fin du programme                 */
+    /* -------------------------------- */
+
+    FREE(pmat);
+
+    FreeFastaSequence(seq);
+    
+    return 0 ;
+}
+

src/prokov/lxpack/src/prokov_learn.c

@@ -0,0 +1,501 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: prokov_learn.c                                            */
+/* @desc: prokov - phase apprentissage                              */
+/* @+           A partir de N sequences d'ADN (format fasta)        */
+/* @+           calcule les occurences de tous les kupleCs sur les  */ 
+/* @+           phases de lecture et ecrit les nombres d'occurence  */
+/* @+           dans le fichier "matrice"                           */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* @+   <Gloup> : Nov 99 : added Markov model for non-coding        */
+/* @+   <Gloup> : Dec 00 : HelixWare port - V1.2                    */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifdef HAS_GETOPT_H
+#include HAS_GETOPT_H
+#endif
+
+#include "fasta_io.h"
+#include "libkov.h"
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX 1024
+#endif
+
+#ifndef BUFSIZ
+#define BUFSIZ 4096
+#endif
+
+/* -------------------------------------------- */
+/* getopt globals                               */
+/* -------------------------------------------- */
+
+        extern char     *optarg;
+        extern int      optind;
+
+/* ---------------------------------------------------- */
+/* copy src into dst                                    */
+/* same as strcpy but works if src and dst overlaps     */
+/* ---------------------------------------------------- */
+static char *sStrCpy(char *dst, char *src)
+{
+    char *d;
+    
+    for (d = dst ; *src ; src++)
+        *d++ = *src;
+
+    *d = '\000';
+    return dst;
+}
+    
+/* ---------------------------------------------------- */
+/* initialise a 0 un tableau d'occurences occ           */
+/* ---------------------------------------------------- */
+static void sInitOcc(int occ[POW_KMAX], int kuple)
+{
+    int j, powk;
+
+    powk = Pow4(kuple);
+
+    for (j = 0 ; j < powk ; j++)
+        occ[j] = 0;
+}
+
+/* ---------------------------------------------------- */
+/* calcule les occurences de tous les kuples dans seq   */
+/* et met occ a jour                                    */
+/*                                                      */
+/* version 'en phase' pour codant                       */
+/*                                                      */
+/* ---------------------------------------------------- */
+static void sAjoutOccC(char* seq, int occ[3][POW_KMAX], int kuple)
+{
+   int i, imax, phase, index;
+
+   imax = strlen(seq) - kuple + 1;
+
+   index = Codage(seq + 0, kuple);   /* valeur initiale */
+   
+   occ[0][index]++;     
+
+   for (i = 1 ; i < imax ; i++) {
+       index = SuiteCodage(seq + i, index, kuple);
+       phase = i % 3;
+       occ[phase][index]++;
+   }   
+}
+
+/* ---------------------------------------------------- */
+/* calcule les occurences de tous les kuples dans seq   */
+/* et met occ a jour                                    */
+/*                                                      */
+/* version 'hors phase' pour non-codant                 */
+/*                                                      */
+/* ---------------------------------------------------- */
+static void sAjoutOccN(char* seq, int occ[POW_KMAX], int kuple)
+{
+   int i, imax, index;
+
+   imax = strlen(seq) - kuple + 1;
+
+   index = Codage(seq + 0, kuple);   /* valeur initiale */
+   
+   occ[index]++;     
+
+   for (i = 1 ; i < imax ; i++) {
+       index = SuiteCodage(seq + i, index, kuple);
+       occ[index]++;
+   }   
+
+}
+
+/* ---------------------------------------------------- */
+/* renormalise un tableau d'occurence                   */
+/* utilise pour renomaliser le non-codant calcule sur   */
+/* les 6 phases                                         */
+/* ---------------------------------------------------- */
+static void sNormalizeOcc(int occ[POW_KMAX], int kuple, int norm)
+{
+   int i, powk;
+   
+   powk = Pow4(kuple);
+   
+   for (i = 0 ; i < powk ; i++)
+        occ[i] /= norm;
+}
+
+/* ---------------------------------------------------- */
+/* occurences simulees pour le non-codant               */
+/* somme du codant sur toutes les phases                */
+/* == codant shuffle en mononucleotides                 */
+/*                                                      */
+/* ceci est utlise lorsqu'on ne connait pas d'exemples  */
+/* de non-codant                                        */
+/*                                                      */
+/* ---------------------------------------------------- */
+static void sNoCodingRan(int occpos[3][POW_KMAX], int occneg[3][POW_KMAX],
+                         int occnoc[POW_KMAX], int kuple)
+{
+   int i, powk, phase, noc;
+
+   powk = Pow4(kuple);
+
+   for (i = 0 ; i < powk ; i++) {
+
+       noc = 0;
+       
+       for (phase = 0 ; phase < 3 ; phase++) {
+           noc += occpos[phase][i];
+           noc += occneg[phase][i];
+       }
+       
+       occnoc[i] = noc;
+   }
+}
+
+/* ----------------------------------------------- */
+/* printout help                                   */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stdout, 
+
+static void sPrintHelp()
+{
+    PP  "------------------------------------------     \n");
+    PP  " Prokov Version %s\n", VERSION);
+    PP  "------------------------------------------     \n");
+    PP  "synopsis :                                     \n");
+    PP  "  Markov/Bayes based gene prediction           \n");
+    PP  "  * learning phase *                           \n");
+    PP  "                                               \n");
+    PP  "usage: prokov_learn [options] [cod [nocod]]    \n");
+    PP  "------------------------------------------     \n");
+    PP  "options:                                       \n");
+    PP  "                                               \n");      
+    PP  "-a : write matrix in [A]scii format            \n");
+    PP  "        default: write in binary format        \n");
+    PP  "                                               \n");      
+    PP  "-h : this [H]elp                               \n");
+    PP  "                                               \n");      
+    PP  "-i : [i]gnore first codon of each sequence     \n");
+    PP  "        default: off                           \n");
+    PP  "                                               \n");      
+    PP  "-I : [I]gnore last codon of each sequence      \n");
+    PP  "        default: off                           \n");
+    PP  "                                               \n");      
+    PP  "-k nn : use [K]uple of size nn                 \n");
+    PP  "        for coding                             \n");
+    PP  "        default: -k %d\n", KUP_DFT);
+    PP  "                                               \n");      
+    PP  "-K nn : use [K]uple of size nn                 \n");
+    PP  "        for non-coding                         \n");
+    PP  "        default: use mean of coding on 6 phases\n");
+    PP  "                                               \n");      
+    PP  "-o name : use name as [O]utput filename        \n");
+    PP  "        default: -o %s\n", MATNAME);
+    PP  "                                               \n");      
+    PP  "-v : set [V]erbose mode                        \n");
+    PP  "                                               \n");      
+    PP  "------------------------------------------     \n");
+    PP  " cod : file containing training genes          \n");
+    PP  "             in Fasta format                   \n");
+    PP  " note: genes may contain Start codon but not   \n");
+    PP  "       Stop codon (see -I option)              \n");
+    PP  " nocod : optional file containing noncoding    \n");
+    PP  "             sequences in Fasta format         \n");
+    PP  "------------------------------------------     \n");
+}
+
+#undef PP
+
+/* ----------------------------------------------- */
+/* printout usage and exit                         */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stderr, 
+
+static int sExitUsage(int stat)
+{
+    PP  "usage: prokov_learn [options] [cod [nocod]]    \n");
+    PP  "type \"prokov_learn -h\" for help              \n");
+
+    if (stat)
+        exit(stat);
+            
+    return stat;
+}
+
+#undef PP
+
+/* ---------------------------------------------------- */
+/*                PROGRAMME PRINCIPAL                   */
+/* ---------------------------------------------------- */
+int main(int argn, char *argv[]) 
+{
+    int  i, nbseqC, nbseqN;
+    int  carg, errflag, aflag, vflag, giflag, iflag, rflag, kflag; 
+
+    MarkovMatrix *pmat;
+
+    FastaSequence *seq;
+
+    FILE *filou;
+
+    char buffer[BUFSIZ];
+    char fileN[FILENAME_MAX], fileC[FILENAME_MAX],
+         outname[FILENAME_MAX];
+
+    /* ------------------------ */
+    /* allocate matrix          */
+    /* (avoid stack overflow    */
+    /*  on some machines)       */
+    /* ------------------------ */
+
+    if (! (pmat = NEW(MarkovMatrix)))
+        Erreur("Not enough memory", 10);
+
+    /* ------------------------ */
+    /* lecture des arguments    */
+    /* ------------------------ */
+
+    /* ------------------------ */
+    /* valeurs par defaut       */
+    
+    errflag = 0;
+ 
+    aflag  = 0;         /* binary output        */
+    vflag  = 0;         /* not verbose          */
+    iflag  = 0;         /* use first            */
+    giflag = 0;         /* use last             */
+    rflag  = 1;         /* use randonm coding   */
+    kflag  = 0;         /* K unset              */
+
+    pmat->kupleC = KUP_DFT;     /* kupleC = 3           */
+    pmat->kupleN = KUP_DFT;     /* kupleN = 3           */
+
+    (void) strcpy(pmat->version, VERSION);
+    (void) strcpy(outname, MATNAME);
+
+    while ((carg = getopt(argn, argv, "ahiIk:K:o:v")) != -1) {
+            
+        switch(carg) {
+
+            case 'a' :              /* ascii mode   */
+                aflag = 1;
+                break;
+
+            case 'h' :              /* help         */
+                sPrintHelp();
+                exit(0);
+                break;
+
+            case 'i' :              /* ignore first  */
+                iflag = 1;
+                break;
+
+            case 'I' :              /* ignore last   */
+                giflag = 1;
+                break;
+
+            case 'k' :              /* kupleC       */
+                if (sscanf(optarg, "%d", &(pmat->kupleC)) != 1)
+                   errflag++;
+                break;
+
+            case 'K' :              /* kupleN       */
+                if (sscanf(optarg, "%d", &(pmat->kupleN)) != 1)
+                   errflag++;
+                rflag = 0;
+                kflag = 1;
+                break;
+
+            case 'o' :              /* output name  */
+                (void) strcpy(outname, optarg);
+                break;
+
+            case 'v' :              /* verbose      */
+                vflag = 1;
+                break;
+
+            case '?' :              /* misusage     */
+                errflag++;
+        }
+    }
+    
+    /* ------------------------ */
+    /* accepts 0, 1 or 2        */
+    /* arguments                */
+
+    if ((argn - optind) == 0) {         /* 0 arg -> <stdin>     */
+        rflag = 1;                      /* use random nocoding  */
+        (void) strcpy(fileC, "<stdin>");
+        (void) strcpy(fileN, "<none>");
+    }
+    else if ((argn - optind) == 1) {    /* 1 arg -> cod         */
+        rflag = 1;                      /* use random nocoding  */
+        (void) strcpy(fileC, argv[optind]);
+        (void) strcpy(fileN, "<none>");
+        if (! AssignToStdin(fileC))
+           errflag++;
+    }
+    else if ((argn - optind) == 2) {    /* 2 args -> cod nocod  */
+        rflag = 0;                      /* use real nocoding    */
+        (void) strcpy(fileC, argv[optind]);
+        (void) strcpy(fileN, argv[optind+1]);
+        if (! AssignToStdin(fileC))
+           errflag++;
+        if (! AssignToStdin(fileN))
+           errflag++;
+    }
+    else
+        errflag++;
+
+    /* ------------------------ */
+    /* check arguments          */
+    
+    if ((rflag) || (! kflag))
+        pmat->kupleN = pmat->kupleC;
+
+    if (pmat->kupleC > K_MAX) {
+        Erreur("kupleC is too large", 0);
+        errflag++;
+    }
+
+    if (pmat->kupleN > K_MAX) {
+        Erreur("kupleN is too large", 0);
+        errflag++;
+    }
+
+    if (! (filou = OpenFile(outname, (aflag ? "w" : "wb"))))
+        errflag++;
+
+    /* ------------------------ */
+    /* exit on usage error      */
+
+    if (errflag) 
+        (void) sExitUsage(1);
+
+    /* ------------------------ */
+    /* initialisations          */
+    /* ------------------------ */
+
+    pmat->powkC = Pow4(pmat->kupleC);
+    pmat->powkN = Pow4(pmat->kupleN);
+
+    for (i = 0 ; i < 3 ; i++) {
+        sInitOcc(pmat->occpos[i], pmat->kupleC);
+        sInitOcc(pmat->occneg[i], pmat->kupleC);
+    }
+    sInitOcc(pmat->occnc, pmat->kupleN);
+
+    seq = NewFastaSequence();
+    
+    /* ------------------------ */
+    /* calcul pour le  codant   */
+    /* ------------------------ */
+
+    nbseqC = 0;
+
+    (void) AssignToStdin(fileC);
+
+    while(ReadFastaSequence(stdin, seq)) {
+
+        if (! seq->ok) {
+           (void) sprintf(buffer, "invalid sequence %s", seq->name);
+           Erreur(buffer, 0);
+           continue;
+        }
+         
+        nbseqC++;
+        
+        if (vflag)
+           (void) fprintf(stderr, "Gene: %s [%ld b]\n", seq->name, seq->length);
+           
+        (void) RNAtoDNA(Upper(seq->seq));
+
+        if (iflag && (seq->length >= 3)) {      /* remove start */
+           (void) sStrCpy(seq->seq, seq->seq+3);
+           seq->length -= 3;
+        }
+        
+        if (giflag && (seq->length > 3)) {      /* remove stop  */
+           seq->seq[seq->length-4] = '\000';
+           seq->length -= 3;
+        }
+        
+        sAjoutOccC(seq->seq, pmat->occpos, pmat->kupleC);       /* brin direct          */
+                                                                /* seulement            */
+#if 0   
+        Complement(Reverse(seq->seq));
+        sAjoutOccC(seq->seq, pmat->occneg, pmat->kupleC);       /* brin complementaire  */
+                                                                /* not needed in V1.2   */
+#endif
+
+    }
+
+                                                                /* brin complementaire  */
+    ComputeNegOccurences(pmat->occneg, pmat->occpos, pmat->kupleC);
+
+    /* --------------------------- */
+    /* calcul pour le noncodant    */
+    /* --------------------------- */
+   
+    nbseqN = 0;
+
+    if (rflag) {
+       sNoCodingRan(pmat->occpos, pmat->occneg, pmat->occnc, pmat->kupleC);
+    }
+    else {
+   
+       (void) AssignToStdin(fileN);
+   
+       while(ReadFastaSequence(stdin, seq)) {
+
+           if (! seq->ok)
+              continue;
+
+           nbseqN++;
+
+           if (vflag)
+              (void) fprintf(stderr, "Non-Coding: %s [%ld b]\n",
+                                     seq->name, seq->length);
+
+           (void) RNAtoDNA(Upper(seq->seq));
+
+           sAjoutOccN(seq->seq, pmat->occnc, pmat->kupleN);  /* brin direct     */
+
+           Complement(Reverse(seq->seq));
+
+           sAjoutOccN(seq->seq, pmat->occnc, pmat->kupleN);  /* complementaire  */
+       }
+    }
+   
+    sNormalizeOcc(pmat->occnc, pmat->kupleN, 6);
+    
+    /* --------------------------- */
+    /* ecriture matrice            */
+    /* --------------------------- */
+
+    if (! WriteMatrix(pmat, aflag, filou))
+       exit(3);
+
+    (void) fclose(filou);
+
+    /* --------------------------- */
+    /* fin de programme            */
+    /* --------------------------- */
+
+    FREE(pmat);
+
+    FreeFastaSequence(seq);
+
+    return 0 ;
+}

src/prokov/lxpack/src/prokov_orf.c

@@ -0,0 +1,324 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: prokov_orf.c                                              */
+/* @desc: prokov - : recherche des orfs                             */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* @+   <Gloup> : Nov 99 : added Markov model for non-coding        */
+/* @+   <Gloup> : Dec 00 : HelixWare port - V1.2                    */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifdef HAS_GETOPT_H
+#include HAS_GETOPT_H
+#endif
+
+#include "fasta_io.h"
+#include "libkov.h"
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX 1024
+#endif
+
+#ifndef BUFSIZ
+#define BUFSIZ 4096
+#endif
+
+#define BIOFRAME 1
+
+/* -------------------------------------------- */
+/* getopt globals                               */
+/* -------------------------------------------- */
+
+        extern char     *optarg;
+        extern int      optind;
+
+/* ----------------------------------------------- */
+/* printout help                                   */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stdout, 
+
+static void sPrintHelp()
+{
+    PP  "------------------------------------------     \n");
+    PP  " Prokov Version %s\n", VERSION);
+    PP  "------------------------------------------     \n");
+    PP  "synopsis :                                     \n");
+    PP  "  Markov/Bayes based gene prediction           \n");
+    PP  "  * simple orfs searching utility *            \n");
+    PP  "                                               \n");
+    PP  "usage: prokov_orf [options] seqfile            \n");
+    PP  "------------------------------------------     \n");
+    PP  "options:                                       \n");
+    PP  "                                               \n");      
+    PP  "-h : this [H]elp                               \n");
+    PP  "                                               \n");      
+    PP  "-l nn : minimun cds [L]ength                   \n");
+    PP  "        default: -l %d\n", MIN_CDS);
+    PP  "                                               \n");      
+    PP  "-o : [O]utput sequence data too (fasta format) \n");
+    PP  "        default: off (short output)            \n");
+    PP  "                                               \n");      
+    PP  "-s string : use string as Starts               \n");
+    PP  "        string has the form \"/XYZ/.../XYZ/\"  \n");
+    PP  "        default: -S %s\n", START_DFT);
+    PP  "                                               \n");      
+    PP  "-S string : use string as Stops                \n");
+    PP  "        string has the form \"/XYZ/.../XYZ/\"  \n");
+    PP  "        default: -S %s\n", STOP_DFT);
+    PP  "                                               \n");      
+    PP  "-v : set [V]erbose mode                        \n");
+    PP  "                                               \n");      
+    PP  "------------------------------------------     \n");
+    PP  " seqfile : file containing one sequence        \n");
+    PP  "             in Fasta format                   \n");
+    PP  "------------------------------------------     \n");
+}
+
+#undef PP
+
+/* ----------------------------------------------- */
+/* printout usage and exit                         */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stderr, 
+
+static int sExitUsage(int stat)
+{
+    PP  "usage: prokov_orf [options] seqfile    \n");
+    PP  "type \"prokov_orf -h\" for help        \n");
+
+    if (stat)
+        exit(stat);
+            
+    return stat;
+}
+
+#undef PP
+
+/* ----------------------------------------------- */
+/* output fragment of sequence (fasta format)      */
+/* ----------------------------------------------- */
+void sOutputSequence(FastaSequence *seq, int posa,
+                     int poss, int strand, 
+                     char *name, char *comment)
+{
+    char save;
+        
+    static FastaSequence sSeq;
+
+    (void) strcpy(sSeq.name, name);
+    (void) strcpy(sSeq.comment, comment);
+
+    sSeq.seq = seq->seq + posa;
+
+    poss += 3;
+
+    save = seq->seq[poss];
+    seq->seq[poss] = '\000';
+    sSeq.length = poss - posa;
+
+    WriteFastaSequence(stdout, &sSeq, FASTA_CHAR_PER_LINE);
+
+    seq->seq[poss] = save;
+}
+
+/* ----------------------------------------------- */
+/* print a CDS                                     */
+/* ----------------------------------------------- */
+
+void sPrintCds(FastaSequence *seq, int strand, int phase,
+               int posa, int poss, int outflag)
+{
+    int from, to, frame;
+    char bufname[BUFSIZ], bufcom[BUFSIZ];
+    
+    from = ((strand > 0) ? posa + 1 : seq->length - poss - 2);
+    to   = ((strand > 0) ? poss + 3 : seq->length - posa);
+
+#if BIOFRAME
+    frame = ((from - 1) % 3 ) + 1;
+#else
+    frame = phase;
+#endif
+
+    (void) sprintf(bufname, "%s_ORF_%d_%d_%s", seq->name,
+                               from, to, ((strand > 0) ? "D" : "C"));  
+
+    (void) sprintf(bufcom, "%d %d %1s%d",
+                   from, to, ((strand > 0) ? "+" : "-"), frame);
+
+     if (outflag)       /* long output */    
+        sOutputSequence(seq, posa, poss, strand, bufname, bufcom);
+     else               /* short output */
+        (void) printf("%s %s\n", bufname, bufcom);
+}
+
+
+/* ----------------------------------------------- */
+/* process cds's in single phase                   */
+/* ----------------------------------------------- */
+static void sProcessSequence(FastaSequence *seq, 
+                int strand, int phase, int mincds, int outflag,
+                char *starts, char *stops)
+{
+    int posa, poss, lencds;
+
+
+    posa = phase;                       /* start on phase */
+    
+    while ((posa = FindCodon(seq->seq, seq->length, starts, posa, seq->length - 1)) >= 0)  {
+
+        poss = FindCodon(seq->seq, seq->length, stops, posa, seq->length - 1);
+
+        if (poss < 0)
+           break;               /* no more stop */
+                
+        lencds = poss - posa;
+             
+        if (lencds < mincds) {
+           posa = poss + 3;     /* try next start */
+           continue;            
+        }
+        
+        sPrintCds(seq, strand, phase, posa, poss, outflag); 
+        posa = poss + 3;
+
+    }
+}
+
+/* ---------------------------------------------------- */
+/*                PROGRAMME PRINCIPAL                   */
+/* ---------------------------------------------------- */
+
+int main(int argn, char *argv[]) {
+
+    /* Declarations */
+
+    int   phase, mincds;
+    int   carg, errflag, vflag, oflag; 
+
+    FastaSequence *seq;
+    
+    FILE  *filin;
+
+    char  stops[256], starts[256];
+    
+    /* ------------------------ */
+    /* lecture des arguments    */
+    /* ------------------------ */
+
+    /* ------------------------ */
+    /* valeurs par defaut       */
+    
+    errflag = 0;
+ 
+    vflag  = 0;         /* not verbose          */
+    oflag  = 0;         /* short output         */
+    
+    mincds = MIN_CDS;   /* min cds length       */
+    
+    (void) strcpy(starts, START_DFT);
+    (void) strcpy(stops,  STOP_DFT);
+
+    while ((carg = getopt(argn, argv, "hl:os:S:v")) != -1) {
+            
+        switch(carg) {
+
+            case 'h' :              /* help         */
+                sPrintHelp();
+                exit(0);
+                break;
+
+            case 'l' :              /* min cds      */
+                if (sscanf(optarg, "%d", &mincds) != 1)
+                   errflag++;
+                break;
+
+            case 'o' :              /* verbose      */
+                oflag = 1;
+                break;
+
+            case 's' :              /* starts       */
+                (void) strcpy(starts, optarg);
+                break;
+
+            case 'S' :              /* stops        */
+                (void) strcpy(stops, optarg);
+                break;
+
+            case 'v' :              /* verbose      */
+                vflag = 1;
+                break;
+
+            case '?' :              /* misusage     */
+                errflag++;
+        }
+    }
+    
+    /* ------------------------ */
+    /* may remain 1 argument    */
+
+    if ((argn - optind) > 1)
+        errflag++;
+    else if ((argn - optind) == 1) {
+        if (! AssignToStdin(argv[optind]))
+           errflag++;
+    }
+
+    /* ------------------------ */
+    /* check arguments          */
+    
+    if (mincds <= 0) {
+        Erreur("invalid mincds value", 0);
+        errflag++;
+    }
+
+    /* ------------------------ */
+    /* exit on usage error      */
+
+    if (errflag) 
+        (void) sExitUsage(1);
+
+    /* -------------------------------- */
+    /* lecture sequence                 */
+    /* -------------------------------- */
+
+    seq = NewFastaSequence();
+    ReadFastaSequence(stdin, seq);
+    (void) RNAtoDNA(Upper(seq->seq));
+
+    /* -------------------------------- */
+    /* recherche des cds dans chaque    */
+    /* phase positive                   */
+    /* -------------------------------- */
+    
+    for (phase = 0 ; phase < 3 ; phase++)
+        sProcessSequence(seq, 1, phase, mincds, oflag, starts, stops);
+
+    /* -------------------------------- */
+    /* recherche des cds dans chaque    */
+    /* phase negative                   */
+    /* -------------------------------- */
+
+    Complement(Reverse(seq->seq));
+
+    for (phase = 0 ; phase < 3 ; phase++)
+        sProcessSequence(seq, -1, phase, mincds, oflag, starts, stops);
+
+    /* -------------------------------- */
+    /* fin du programme                 */
+    /* -------------------------------- */
+
+    FreeFastaSequence(seq);
+    
+    return 0 ;
+}
+

src/prokov/lxpack/src/prokov_score.c

@@ -0,0 +1,382 @@
+/* ---------------------------------------------------------------- */
+/* Copyright (c) Atelier de BioInformatique                         */
+/* @file: prokov_score.c                                            */
+/* @desc: prokov - phase detection : scoring                        */
+/*                                                                  */
+/* @history:                                                        */
+/* @+   <Fred Nikitin + Marc Heuveline> : Aug 99 : first version    */
+/* @+   <Gloup> : Oct 99 : last revised version                     */
+/* @+   <Gloup> : Nov 99 : added Markov model for non-coding        */
+/* @+   <Gloup> : Dec 00 : HelixWare port - V1.2                    */
+/* ---------------------------------------------------------------- */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+#ifdef HAS_GETOPT_H
+#include HAS_GETOPT_H
+#endif
+
+#include "fasta_io.h"
+#include "libkov.h"
+
+#ifndef FILENAME_MAX
+#define FILENAME_MAX 1024
+#endif
+
+#ifndef BUFSIZ
+#define BUFSIZ 4096
+#endif
+
+/* -------------------------------------------- */
+/* getopt globals                               */
+/* -------------------------------------------- */
+
+        extern char     *optarg;
+        extern int      optind;
+
+/* ----------------------------------------------- */
+/* printout help                                   */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stdout, 
+
+static void sPrintHelp()
+{
+    PP  "------------------------------------------     \n");
+    PP  " Prokov Version %s\n", VERSION);
+    PP  "------------------------------------------     \n");
+    PP  "synopsis :                                     \n");
+    PP  "  Markov/Bayes based gene prediction           \n");
+    PP  "  * detection phase - score CDS's *            \n");
+    PP  "                                               \n");
+    PP  "usage: prokov_score [options] fastafile        \n");
+    PP  "------------------------------------------     \n");
+    PP  "options:                                       \n");
+    PP  "                                               \n");      
+    PP  "-a : read matrix in [A]scii format             \n");
+    PP  "        default: read in binary format         \n");
+    PP  "                                               \n");      
+    PP  "-h : this [H]elp                               \n");
+    PP  "                                               \n");      
+    PP  "-I : [I]gnore last codon of each sequence      \n");
+    PP  "        default: off                           \n");
+    PP  "                                               \n");      
+    PP  "-m name : [M]atrix filename                    \n");
+    PP  "        default: -m %s\n", MATNAME);
+    PP  "                                               \n");      
+    PP  "-o : [O]utput sequence data too (fasta format) \n");
+    PP  "        default: off (short output)            \n");
+    PP  "                                               \n");      
+    PP  "-p nn : use nn %% as prior coding probability  \n");
+    PP  "        default: -p %d\n", PCODANT);
+    PP  "                                               \n");      
+    PP  "-S string : use string as [S]tops              \n");
+    PP  "        string has the form \"/XYZ/.../XYZ/\"  \n");
+    PP  "        default: -S %s\n", STOP_DFT);
+    PP  "        note: this is only useful with         \n");
+    PP  "              the -z option                    \n");
+    PP  "                                               \n");      
+    PP  "-t nn : lower [T]hreshold - output only        \n");
+    PP  "        if P[frame1] >= nn %%                  \n");
+    PP  "        default: -t 0                          \n");
+    PP  "        note: may be combined with -T          \n");
+    PP  "                                               \n");      
+    PP  "-T nn : upper [T]hreshold - output only        \n");
+    PP  "        if P[frame1] <= nn %%                  \n");
+    PP  "        default: -T 100                        \n");
+    PP  "        note: may be combined with -t          \n");
+    PP  "                                               \n");      
+    PP  "-v : set [V]erbose mode                        \n");
+    PP  "                                               \n");      
+    PP  "-z : force proba to -1 if stop codon           \n");
+    PP  "        default: off                           \n");
+    PP  "                                               \n");      
+    PP  "------------------------------------------     \n");
+    PP  " seqfile : file containing CDS sequences       \n");
+    PP  "             in Fasta format                   \n");
+    PP  "------------------------------------------     \n");
+}
+
+#undef PP
+
+/* ----------------------------------------------- */
+/* printout usage and exit                         */
+/* ----------------------------------------------- */
+
+#define PP (void) fprintf(stderr, 
+
+static int sExitUsage(int stat)
+{
+    PP  "usage: prokov_curve [options] seqfile  \n");
+    PP  "type \"prokov_curve -h\" for help      \n");
+
+    if (stat)
+        exit(stat);
+            
+    return stat;
+}
+
+#undef PP
+
+/* ---------------------------------------------------- */
+/*                PROGRAMME PRINCIPAL                   */
+/* ---------------------------------------------------- */
+
+int main(int argn, char *argv[]) {
+
+    /* Declarations */
+
+    int   i, lenseq, prior, upthres, lothres;
+    int   carg, errflag, aflag, vflag, zflag, iflag, oflag; 
+    float zupthres, zlothres;
+
+    MarkovMatrix *pmat;
+    ProbaArray   win, baye;
+    
+    FastaSequence *seq;
+    
+    FILE  *filin;
+    
+    char  stops[256], cstops[256], buffer[BUFSIZ], bufnum[BUFSIZ];
+
+    char  inname[FILENAME_MAX];
+
+    /* ------------------------ */
+    /* allocate matrix          */
+    /* (avoid stack overflow    */
+    /*  on some machines)       */
+    /* ------------------------ */
+
+    if (! (pmat = NEW(MarkovMatrix)))
+        Erreur("Not enough memory", 10);
+
+    /* ------------------------ */
+    /* lecture des arguments    */
+    /* ------------------------ */
+
+    /* ------------------------ */
+    /* valeurs par defaut       */
+    
+    errflag = 0;
+ 
+    aflag  = 0;         /* binary input         */
+    iflag  = 0;         /* use last codon       */
+    vflag  = 0;         /* not verbose          */
+    zflag  = 0;         /* no zero stops        */
+    oflag  = 0;         /* short output         */
+    
+    prior  = PCODANT;   /* 80% coding           */
+    upthres = 100;      /* upper threshold      */
+    lothres = 0;        /* lower threshold      */
+
+    (void) strcpy(inname, MATNAME);
+    (void) strcpy(stops, STOP_DFT);
+
+    while ((carg = getopt(argn, argv, "ahIm:op:S:t:T:vz")) != -1) {
+            
+        switch(carg) {
+
+            case 'a' :              /* ascii mode   */
+                aflag = 1;
+                break;
+
+            case 'h' :              /* help         */
+                sPrintHelp();
+                exit(0);
+                break;
+
+            case 'I' :              /* Ignore last  */
+                iflag = 1;
+                break;
+
+            case 'm' :              /* matrix name  */
+                (void) strcpy(inname, optarg);
+                break;
+
+            case 'o' :              /* long output */
+                oflag = 1;
+                break;
+
+            case 'p' :              /* prior        */
+                if (sscanf(optarg, "%d", &prior) != 1)
+                   errflag++;
+                break;
+
+            case 'S' :              /* stops        */
+                (void) strcpy(stops, optarg);
+                break;
+
+            case 't' :              /* low thresh.  */
+                if (sscanf(optarg, "%d", & lothres) != 1)
+                   errflag++;
+                break;
+
+            case 'T' :              /* up thresh.   */
+                if (sscanf(optarg, "%d", & upthres) != 1)
+                   errflag++;
+                break;
+
+            case 'v' :              /* verbose      */
+                vflag = 1;
+                break;
+
+            case 'z' :              /* zero stop    */
+                zflag = 1;
+                break;
+
+            case '?' :              /* misusage     */
+                errflag++;
+        }
+    }
+    
+    /* ------------------------ */
+    /* may remain 1 argument    */
+
+    if ((argn - optind) > 1)
+        errflag++;
+    else if ((argn - optind) == 1) {
+        if (! AssignToStdin(argv[optind]))
+           errflag++;
+    }
+
+    /* ------------------------ */
+    /* check arguments          */
+    
+    if ((prior <= 0) || (prior >= 100)) {
+        Erreur("invalid prior value", 0);
+        errflag++;
+    }
+
+    if ((lothres < 0) || (lothres > 100)) {
+        Erreur("invalid lower threshold (-o) value", 0);
+        errflag++;
+    }
+
+    if ((upthres < 0) || (upthres > 100)) {
+        Erreur("invalid upper threshold (-O) value", 0);
+        errflag++;
+    }
+
+    if (upthres < lothres) {
+        Erreur("incoherent lower/upper threshold (-o -O) values", 0);
+        errflag++;
+    }
+
+    if (! (filin = OpenFile(MatrixPathName(inname), (aflag ? "r" : "rb"))))
+        errflag++;
+
+    /* ------------------------ */
+    /* exit on usage error      */
+
+    if (errflag) 
+        (void) sExitUsage(1);
+
+    /* ------------------------ */
+    /* initialize codons        */
+    
+    Complement(Reverse(strcpy(cstops,  stops)));
+
+    /* -------------------------------- */
+    /* lecture matrice                  */
+    /* -------------------------------- */
+
+    if (! ReadMatrix(pmat, aflag, filin))
+       exit(3);
+
+    (void) fclose(filin);
+
+    /* -------------------------------- */
+    /* calcul des proba de transition   */
+    /* et probas initiales              */
+    /* -------------------------------- */
+    
+    ProbaCond(pmat);   
+
+    zlothres = ((float) lothres) / 100.;
+    zupthres = ((float) upthres) / 100.;
+
+    /* -------------------------------- */
+    /* boucle lecture des sequences     */
+    /* -------------------------------- */
+
+    seq = NewFastaSequence();
+
+    while (ReadFastaSequence(stdin, seq)) {
+
+       if (! seq->ok) {
+           (void) sprintf(buffer, "invalid sequence %s", seq->name);
+           Erreur(buffer, 0);
+           continue;
+       }
+       
+       if (vflag)
+          (void) fprintf(stderr, "%s [%ld b]\n", seq->name, seq->length);
+        
+       RNAtoDNA(Upper(seq->seq));
+
+       if (iflag && (seq->length >= 4)) {
+          seq->seq[seq->length-4] = '\000';
+          seq->length -= 3;
+       }
+       
+       lenseq = seq->length - MAX(pmat->kupleC, pmat->kupleN) + 1;
+       
+       ProbaMarkov(seq->seq, lenseq, pmat, &win);
+
+       ProbaBayes(&win, (float) prior / 100., &baye);
+
+       if (zflag) {                             /* -1 score when stop */
+
+          for (i = 0 ; i < 3 ; i++) {
+             if (FindCodon(seq->seq, seq->length, stops, i, seq->length - 1) >= 0)
+                baye.probpos[i] = -1.;
+          }       
+          
+          for (i = 0 ; i < 3 ; i++) {
+             if (FindCodon(seq->seq, seq->length, cstops, i, seq->length - 1) >= 0)
+                baye.probneg[i] = -1.;
+          }
+       }
+       
+                                                /* output sequence      */
+
+       if ((baye.probpos[0] >= zlothres) && (baye.probpos[0] <= zupthres)) {
+
+           (void) strcpy(buffer, " | ");
+
+           for (i = 0 ; i < 3 ; i++) {
+              (void) sprintf(bufnum, "%6.3f ", baye.probpos[InternalFrame(i, 1, seq->length)]);
+              (void) strcat(buffer, bufnum);
+           }
+           for (i = 0 ; i < 3 ; i++) {
+              (void) sprintf(bufnum, "%6.3f ", baye.probneg[InternalFrame(i, 0, seq->length)]);
+              (void) strcat(buffer, bufnum);
+           }
+           (void) sprintf(bufnum, "%6.3f", baye.probnc);
+           (void) strcat(buffer, bufnum);
+
+           if (oflag) {
+              seq->comment[MAX(0, FASTA_COMLEN - strlen(buffer) - 1)] = '\000';
+              (void) strcat(seq->comment, buffer);         
+              WriteFastaSequence(stdout, seq, FASTA_CHAR_PER_LINE);
+           }
+           else
+                printf("%s %s\n", seq->name, buffer + 3);
+       }
+
+    }
+
+    /* -------------------------------- */
+    /* fin du programme                 */
+    /* -------------------------------- */
+
+    FREE(pmat);
+
+    FreeFastaSequence(seq);
+    
+    return 0 ;
+}
+

src/prokov/lxpack/tests/Makefile

@@ -0,0 +1,25 @@
+# ---------------------------------------------------------------
+# $Id: $
+# ---------------------------------------------------------------
+# @file: Makefile
+# @desc: makefile for kimono/test
+#
+# @history:
+# @history:
+# @+	    <Gloup> : Apr 97 : Created
+# @+	    <Gloup> : Mar 02 : Updated for LXxware
+#
+# @note: should be processed with gnu compatible make
+# @note: helixware_compatible
+#
+# @end:
+# ---------------------------------------------------------------
+#
+
+include ../config/targets/empty.targ
+
+clean::
+	-\rm -f *.bak
+
+test::
+	./test.csh

src/prokov/lxpack/tests/Matrix

@@ -0,0 +1,129 @@
+v1.2 3 3 64 64
+7299	6383	6114	
+2621	2379	2606	
+3158	6294	1823	
+3353	2678	3571	
+3212	2735	2022	
+1284	1604	895	
+2254	2757	920	
+1331	1343	1513	
+1567	2091	5332	
+2053	3488	3181	
+608	2984	2610	
+992	1128	2156	
+1336	3645	1524	
+3892	2805	1611	
+3967	4958	880	
+5483	2726	3025	
+2949	3158	3114	
+1141	1349	1628	
+2818	3471	1870	
+2311	1830	3574	
+1109	1494	1603	
+486	775	976	
+2371	2078	1335	
+1592	959	1436	
+650	2702	2689	
+1370	1952	2138	
+1027	2641	3950	
+1176	1240	1949	
+739	1216	1140	
+1648	1188	1061	
+3433	3545	786	
+3494	1799	2180	
+7486	2143	4043	
+2860	771	1895	
+3715	1636	1034	
+5013	886	3597	
+3256	2263	2548	
+2350	1433	1790	
+2984	2323	1115	
+2870	1532	4215	
+3219	1506	3978	
+3449	1286	2550	
+1697	1456	1662	
+1880	695	1965	
+1978	916	1155	
+2524	741	1183	
+2662	1872	520	
+2823	1074	2213	
+289	2430	3160	
+1817	851	1952	
+65	1878	493	
+3457	1646	3533	
+2231	3694	3046	
+1186	1538	1897	
+926	3568	853	
+1955	1333	2150	
+146	4270	7075	
+679	2942	3591	
+1611	3074	2023	
+555	2008	3874	
+2752	3361	1809	
+2069	3212	2443	
+2232	6188	805	
+4495	3534	4076	
+5316
+2286
+3124
+3472
+2401
+1387
+1716
+1410
+2404
+2889
+1698
+1410
+2523
+2967
+2920
+3472
+3074
+1528
+2653
+2920
+1819
+1175
+2233
+1698
+1898
+1980
+2233
+1716
+921
+1713
+2653
+3124
+3566
+1662
+1713
+2967
+2546
+2143
+1980
+2889
+2220
+2143
+1175
+1387
+1444
+1662
+1528
+2286
+2300
+1444
+921
+2523
+3410
+2220
+1898
+2404
+3410
+2546
+1819
+2401
+2300
+3566
+3074
+5316

src/prokov/lxpack/tests/S.curve.ref

@@ -0,0 +1,45 @@
+    61	0.999	0.000	0.000	0.000	0.000	0.000	0.001
+    91	0.979	0.000	0.000	0.000	0.000	0.000	0.021
+   121	0.967	0.000	0.000	0.000	0.000	0.000	0.033
+   151	0.977	0.000	0.000	0.000	0.000	0.000	0.023
+   181	0.997	0.000	0.000	0.000	0.000	0.000	0.003
+   211	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   241	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   271	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   301	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   331	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   361	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   391	0.999	0.000	0.000	0.000	0.000	0.000	0.001
+   421	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   451	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   481	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   511	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   541	0.576	0.007	0.417	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.427	0.224	0.349	0.000	0.000	0.000	0.000
+   661	0.407	0.214	0.332	0.000	0.000	0.000	0.046
+   691	0.004	0.002	0.003	0.018	0.009	0.015	0.949
+   721	0.000	0.000	0.000	0.423	0.222	0.345	0.010
+   751	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   781	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   811	0.000	0.000	0.000	0.000	0.566	0.434	0.000
+   841	0.000	0.000	0.000	0.030	0.000	0.969	0.001
+   871	0.000	0.000	0.000	0.994	0.000	0.000	0.006
+   901	0.000	0.000	0.000	0.993	0.000	0.000	0.007
+   931	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+   961	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+   991	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  1021	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1051	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1081	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1111	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1141	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1171	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1201	0.000	0.000	0.000	0.993	0.000	0.000	0.007
+  1231	0.000	0.000	0.000	0.973	0.000	0.000	0.027
+  1261	0.000	0.000	0.000	0.967	0.000	0.000	0.032
+  1291	0.000	0.000	0.000	0.994	0.000	0.000	0.006
+  1321	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  1351	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1381	0.000	0.000	0.000	0.434	0.001	0.565	0.000

src/prokov/lxpack/tests/S.fasta

@@ -0,0 +1,34 @@
+>test
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

src/prokov/lxpack/tests/St.curve.ref

@@ -0,0 +1,45 @@
+    61	0.999	0.000	0.000	0.000	0.000	0.000	0.001
+    91	0.979	0.000	0.000	0.000	0.000	0.000	0.021
+   121	0.967	0.000	0.000	0.000	0.000	0.000	0.033
+   151	0.977	0.000	0.000	0.000	0.000	0.000	0.023
+   181	0.997	0.000	0.000	0.000	0.000	0.000	0.003
+   211	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   241	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   271	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   301	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   331	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   361	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   391	0.999	0.000	0.000	0.000	0.000	0.000	0.001
+   421	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   451	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   481	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   511	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   541	0.576	0.007	0.417	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.427	0.224	0.349	0.000	0.000	0.000	0.000
+   661	0.407	0.214	0.332	0.000	0.000	0.000	0.046
+   691	0.004	0.002	0.003	0.015	0.018	0.009	0.949
+   721	0.000	0.000	0.000	0.345	0.423	0.222	0.010
+   751	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   781	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   811	0.000	0.000	0.000	0.434	0.000	0.566	0.000
+   841	0.000	0.000	0.000	0.969	0.030	0.000	0.001
+   871	0.000	0.000	0.000	0.000	0.994	0.000	0.006
+   901	0.000	0.000	0.000	0.000	0.993	0.000	0.007
+   931	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   961	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   991	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  1021	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1051	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1081	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1111	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1141	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1171	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1201	0.000	0.000	0.000	0.000	0.993	0.000	0.007
+  1231	0.000	0.000	0.000	0.000	0.973	0.000	0.027
+  1261	0.000	0.000	0.000	0.000	0.967	0.000	0.032
+  1291	0.000	0.000	0.000	0.000	0.994	0.000	0.006
+  1321	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  1351	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1381	0.000	0.000	0.000	0.565	0.434	0.001	0.000

src/prokov/lxpack/tests/St.fasta

@@ -0,0 +1,35 @@
+>test
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+T

src/prokov/lxpack/tests/Stt.curve.ref

@@ -0,0 +1,45 @@
+    61	0.999	0.000	0.000	0.000	0.000	0.000	0.001
+    91	0.979	0.000	0.000	0.000	0.000	0.000	0.021
+   121	0.967	0.000	0.000	0.000	0.000	0.000	0.033
+   151	0.977	0.000	0.000	0.000	0.000	0.000	0.023
+   181	0.997	0.000	0.000	0.000	0.000	0.000	0.003
+   211	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   241	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   271	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   301	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   331	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   361	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   391	0.999	0.000	0.000	0.000	0.000	0.000	0.001
+   421	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   451	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   481	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   511	1.000	0.000	0.000	0.000	0.000	0.000	0.000
+   541	0.576	0.007	0.417	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.427	0.224	0.349	0.000	0.000	0.000	0.000
+   661	0.407	0.214	0.332	0.000	0.000	0.000	0.046
+   691	0.004	0.002	0.003	0.009	0.015	0.018	0.949
+   721	0.000	0.000	0.000	0.222	0.345	0.423	0.010
+   751	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   781	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   811	0.000	0.000	0.000	0.566	0.434	0.000	0.000
+   841	0.000	0.000	0.000	0.000	0.969	0.030	0.001
+   871	0.000	0.000	0.000	0.000	0.000	0.994	0.006
+   901	0.000	0.000	0.000	0.000	0.000	0.993	0.007
+   931	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+   961	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+   991	0.000	0.000	0.000	0.000	0.000	0.999	0.001
+  1021	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1051	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1081	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1111	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1141	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1171	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1201	0.000	0.000	0.000	0.000	0.000	0.993	0.007
+  1231	0.000	0.000	0.000	0.000	0.000	0.973	0.027
+  1261	0.000	0.000	0.000	0.000	0.000	0.967	0.032
+  1291	0.000	0.000	0.000	0.000	0.000	0.994	0.006
+  1321	0.000	0.000	0.000	0.000	0.000	0.999	0.001
+  1351	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1381	0.000	0.000	0.000	0.001	0.565	0.434	0.000

src/prokov/lxpack/tests/Stt.fasta

@@ -0,0 +1,35 @@
+>test
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TT

src/prokov/lxpack/tests/aS.curve.ref

@@ -0,0 +1,45 @@
+    61	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+    91	0.000	0.982	0.000	0.000	0.000	0.000	0.018
+   121	0.000	0.960	0.000	0.000	0.000	0.000	0.040
+   151	0.000	0.982	0.000	0.000	0.000	0.000	0.018
+   181	0.000	0.996	0.000	0.000	0.000	0.000	0.004
+   211	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   241	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   271	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   301	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   331	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   361	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   391	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+   421	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   451	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   481	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   511	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   541	0.469	0.529	0.002	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.503	0.328	0.169	0.000	0.000	0.000	0.000
+   661	0.435	0.362	0.169	0.000	0.000	0.000	0.035
+   691	0.005	0.005	0.002	0.010	0.008	0.014	0.956
+   721	0.000	0.000	0.000	0.316	0.244	0.427	0.013
+   751	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   781	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   811	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   841	0.000	0.000	0.000	0.044	0.000	0.955	0.001
+   871	0.000	0.000	0.000	0.996	0.000	0.000	0.004
+   901	0.000	0.000	0.000	0.987	0.000	0.000	0.013
+   931	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+   961	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+   991	0.000	0.000	0.000	0.998	0.000	0.000	0.002
+  1021	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1051	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1081	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1111	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1141	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1171	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1201	0.000	0.000	0.000	0.991	0.000	0.000	0.009
+  1231	0.000	0.000	0.000	0.915	0.000	0.000	0.084
+  1261	0.000	0.000	0.000	0.928	0.000	0.000	0.072
+  1291	0.000	0.000	0.000	0.992	0.000	0.000	0.008
+  1321	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  1351	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1381	0.000	0.000	0.000	0.737	0.001	0.263	0.000

src/prokov/lxpack/tests/aS.fasta

@@ -0,0 +1,35 @@
+>test
+A
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

src/prokov/lxpack/tests/aSt.curve.ref

@@ -0,0 +1,45 @@
+    61	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+    91	0.000	0.982	0.000	0.000	0.000	0.000	0.018
+   121	0.000	0.960	0.000	0.000	0.000	0.000	0.040
+   151	0.000	0.982	0.000	0.000	0.000	0.000	0.018
+   181	0.000	0.996	0.000	0.000	0.000	0.000	0.004
+   211	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   241	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   271	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   301	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   331	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   361	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   391	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+   421	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   451	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   481	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   511	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   541	0.469	0.529	0.002	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.503	0.328	0.169	0.000	0.000	0.000	0.000
+   661	0.435	0.362	0.169	0.000	0.000	0.000	0.035
+   691	0.005	0.005	0.002	0.014	0.010	0.008	0.956
+   721	0.000	0.000	0.000	0.427	0.316	0.244	0.013
+   751	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   781	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   811	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   841	0.000	0.000	0.000	0.955	0.044	0.000	0.001
+   871	0.000	0.000	0.000	0.000	0.996	0.000	0.004
+   901	0.000	0.000	0.000	0.000	0.987	0.000	0.013
+   931	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   961	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   991	0.000	0.000	0.000	0.000	0.998	0.000	0.002
+  1021	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1051	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1081	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1111	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1141	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1171	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1201	0.000	0.000	0.000	0.000	0.991	0.000	0.009
+  1231	0.000	0.000	0.000	0.000	0.915	0.000	0.084
+  1261	0.000	0.000	0.000	0.000	0.928	0.000	0.072
+  1291	0.000	0.000	0.000	0.000	0.992	0.000	0.008
+  1321	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  1351	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1381	0.000	0.000	0.000	0.263	0.737	0.001	0.000

src/prokov/lxpack/tests/aSt.fasta

@@ -0,0 +1,36 @@
+>test
+A
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+T

src/prokov/lxpack/tests/aStt.curve.ref

@@ -0,0 +1,45 @@
+    61	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+    91	0.000	0.982	0.000	0.000	0.000	0.000	0.018
+   121	0.000	0.960	0.000	0.000	0.000	0.000	0.040
+   151	0.000	0.982	0.000	0.000	0.000	0.000	0.018
+   181	0.000	0.996	0.000	0.000	0.000	0.000	0.004
+   211	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   241	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   271	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   301	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   331	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   361	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   391	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+   421	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   451	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   481	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   511	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   541	0.469	0.529	0.002	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.503	0.328	0.169	0.000	0.000	0.000	0.000
+   661	0.435	0.362	0.169	0.000	0.000	0.000	0.035
+   691	0.005	0.005	0.002	0.008	0.014	0.010	0.956
+   721	0.000	0.000	0.000	0.244	0.427	0.316	0.013
+   751	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   781	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   811	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   841	0.000	0.000	0.000	0.000	0.955	0.044	0.001
+   871	0.000	0.000	0.000	0.000	0.000	0.996	0.004
+   901	0.000	0.000	0.000	0.000	0.000	0.987	0.013
+   931	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+   961	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+   991	0.000	0.000	0.000	0.000	0.000	0.998	0.002
+  1021	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1051	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1081	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1111	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1141	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1171	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1201	0.000	0.000	0.000	0.000	0.000	0.991	0.009
+  1231	0.000	0.000	0.000	0.000	0.000	0.915	0.084
+  1261	0.000	0.000	0.000	0.000	0.000	0.928	0.072
+  1291	0.000	0.000	0.000	0.000	0.000	0.992	0.008
+  1321	0.000	0.000	0.000	0.000	0.000	0.999	0.001
+  1351	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1381	0.000	0.000	0.000	0.001	0.263	0.737	0.000

src/prokov/lxpack/tests/aStt.fasta

@@ -0,0 +1,36 @@
+>test
+A
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TT

src/prokov/lxpack/tests/aaS.curve.ref

@@ -0,0 +1,45 @@
+    61	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+    91	0.000	0.000	0.984	0.000	0.000	0.000	0.016
+   121	0.000	0.000	0.958	0.000	0.000	0.000	0.042
+   151	0.000	0.000	0.980	0.000	0.000	0.000	0.020
+   181	0.000	0.000	0.997	0.000	0.000	0.000	0.003
+   211	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   241	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   271	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   301	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   331	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   361	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   391	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+   421	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   451	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   481	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   511	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   541	0.001	0.469	0.530	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.334	0.401	0.265	0.000	0.000	0.000	0.000
+   661	0.240	0.421	0.311	0.000	0.000	0.000	0.028
+   691	0.004	0.006	0.005	0.010	0.005	0.012	0.959
+   721	0.000	0.000	0.000	0.369	0.172	0.443	0.017
+   751	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   781	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   811	0.000	0.000	0.000	0.309	0.322	0.369	0.000
+   841	0.000	0.000	0.000	0.030	0.000	0.969	0.001
+   871	0.000	0.000	0.000	0.996	0.000	0.000	0.004
+   901	0.000	0.000	0.000	0.986	0.000	0.000	0.014
+   931	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+   961	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+   991	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  1021	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1051	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1081	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1111	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1141	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1171	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1201	0.000	0.000	0.000	0.994	0.000	0.000	0.006
+  1231	0.000	0.000	0.000	0.930	0.000	0.000	0.070
+  1261	0.000	0.000	0.000	0.922	0.000	0.000	0.078
+  1291	0.000	0.000	0.000	0.992	0.000	0.000	0.008
+  1321	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  1351	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  1381	0.000	0.000	0.000	0.962	0.001	0.037	0.000

src/prokov/lxpack/tests/aaS.fasta

@@ -0,0 +1,35 @@
+>test
+AA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT

src/prokov/lxpack/tests/aaSt.curve.ref

@@ -0,0 +1,45 @@
+    61	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+    91	0.000	0.000	0.984	0.000	0.000	0.000	0.016
+   121	0.000	0.000	0.958	0.000	0.000	0.000	0.042
+   151	0.000	0.000	0.980	0.000	0.000	0.000	0.020
+   181	0.000	0.000	0.997	0.000	0.000	0.000	0.003
+   211	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   241	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   271	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   301	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   331	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   361	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   391	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+   421	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   451	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   481	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   511	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   541	0.001	0.469	0.530	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.334	0.401	0.265	0.000	0.000	0.000	0.000
+   661	0.240	0.421	0.311	0.000	0.000	0.000	0.028
+   691	0.004	0.006	0.005	0.012	0.010	0.005	0.959
+   721	0.000	0.000	0.000	0.443	0.369	0.172	0.017
+   751	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   781	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   811	0.000	0.000	0.000	0.369	0.309	0.322	0.000
+   841	0.000	0.000	0.000	0.969	0.030	0.000	0.001
+   871	0.000	0.000	0.000	0.000	0.996	0.000	0.004
+   901	0.000	0.000	0.000	0.000	0.986	0.000	0.014
+   931	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   961	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   991	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  1021	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1051	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1081	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1111	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1141	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1171	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1201	0.000	0.000	0.000	0.000	0.994	0.000	0.006
+  1231	0.000	0.000	0.000	0.000	0.930	0.000	0.070
+  1261	0.000	0.000	0.000	0.000	0.922	0.000	0.078
+  1291	0.000	0.000	0.000	0.000	0.992	0.000	0.008
+  1321	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  1351	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  1381	0.000	0.000	0.000	0.037	0.962	0.001	0.000

src/prokov/lxpack/tests/aaSt.fasta

@@ -0,0 +1,36 @@
+>test
+AA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+T

src/prokov/lxpack/tests/aaStt.curve.ref

@@ -0,0 +1,45 @@
+    61	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+    91	0.000	0.000	0.984	0.000	0.000	0.000	0.016
+   121	0.000	0.000	0.958	0.000	0.000	0.000	0.042
+   151	0.000	0.000	0.980	0.000	0.000	0.000	0.020
+   181	0.000	0.000	0.997	0.000	0.000	0.000	0.003
+   211	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   241	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   271	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   301	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   331	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   361	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   391	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+   421	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   451	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   481	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   511	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+   541	0.001	0.469	0.530	0.000	0.000	0.000	0.000
+   571	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   601	0.369	0.309	0.322	0.000	0.000	0.000	0.000
+   631	0.334	0.401	0.265	0.000	0.000	0.000	0.000
+   661	0.240	0.421	0.311	0.000	0.000	0.000	0.028
+   691	0.004	0.006	0.005	0.005	0.012	0.010	0.959
+   721	0.000	0.000	0.000	0.172	0.443	0.369	0.017
+   751	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   781	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   811	0.000	0.000	0.000	0.322	0.369	0.309	0.000
+   841	0.000	0.000	0.000	0.000	0.969	0.030	0.001
+   871	0.000	0.000	0.000	0.000	0.000	0.996	0.004
+   901	0.000	0.000	0.000	0.000	0.000	0.986	0.014
+   931	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+   961	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+   991	0.000	0.000	0.000	0.000	0.000	0.999	0.001
+  1021	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1051	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1081	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1111	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1141	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1171	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1201	0.000	0.000	0.000	0.000	0.000	0.994	0.006
+  1231	0.000	0.000	0.000	0.000	0.000	0.930	0.070
+  1261	0.000	0.000	0.000	0.000	0.000	0.922	0.078
+  1291	0.000	0.000	0.000	0.000	0.000	0.992	0.008
+  1321	0.000	0.000	0.000	0.000	0.000	0.999	0.001
+  1351	0.000	0.000	0.000	0.000	0.000	1.000	0.000
+  1381	0.000	0.000	0.000	0.001	0.037	0.962	0.000

src/prokov/lxpack/tests/aaStt.fasta

@@ -0,0 +1,36 @@
+>test
+AA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+ATGAAAACTGAAAACGCAAAAACAAATCAAACATTAGTTGAGAATTCACT
+GAACACACAATTATCAAACTGGTTTCTTTTATACTCTAAGCTCCACCGTT
+TCCATTGGTATGTGAAAGGGCCTCATTTCTTTACATTGCACGAGAAATTT
+GAAGAACTTTATGACCATGCGGCTGAAACAGTGGATACCATCGCTGAGCG
+CCTGCTGGCGATTGGCGGACAGCCTGTTGCCACAGTGAAAGAATACACTG
+AGCATGCATCTATCACAGACGGCGGAAACGAAACATCAGCATCAGAAATG
+GTACAAGCATTGGTAAACGACTACAAACAAATCAGCAGCGAATCTAAATT
+CGTGATCGGCCTGGCTGAAGAAAATCAAGACAATGCGACAGCGGACTTGT
+TTGTCGGATTAATTGAAGAAGTTGAAAAACAAGTGTGGATGCTTTCCTCT
+TATTTAGGGTAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTACCCTA
+AATAAGAGGAAAGCATCCACACTTGTTTTTCAACTTCTTCAATTAATCCG
+ACAAACAAGTCCGCTGTCGCATTGTCTTGATTTTCTTCAGCCAGGCCGAT
+CACGAATTTAGATTCGCTGCTGATTTGTTTGTAGTCGTTTACCAATGCTT
+GTACCATTTCTGATGCTGATGTTTCGTTTCCGCCGTCTGTGATAGATGCA
+TGCTCAGTGTATTCTTTCACTGTGGCAACAGGCTGTCCGCCAATCGCCAG
+CAGGCGCTCAGCGATGGTATCCACTGTTTCAGCCGCATGGTCATAAAGTT
+CTTCAAATTTCTCGTGCAATGTAAAGAAATGAGGCCCTTTCACATACCAA
+TGGAAACGGTGGAGCTTAGAGTATAAAAGAAACCAGTTTGATAATTGTGT
+GTTCAGTGAATTCTCAACTAATGTTTGATTTGTTTTTGCGTTTTCAGTTT
+TCAT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
+TT

src/prokov/lxpack/tests/bacil.test

@@ -0,0 +1,201 @@
+>BASU fragment from 290001 to 300000 - 10000 bp
+ATTGAATGCCTTCCGCTGGATCGGTGCAGGCTTCCATGCAGTCCGCGATTT
+TCTGACGGATATACTCCTTCATCTCATTCACGGCTTCGATCGCAAGCTGT
+TCTTTACCCCCGGGAAAGTGGTAGTAAAGAGAGCCTTTAGGCGCGCCGCT
+TTCCTTTATAATCTGGTTCAGCCCCGTGCCGTAATACCCTTGCAGCTGAA
+AAAGCCGGGTAGCTGCCGAAAGGATTTTCTCACGGGAATCTCCATAACTC
+ATAACATTCCCACCTTACTGAATTGCAATCAAAAATATAGTGACTGGTCT
+ATTATCTTGATTCAATCATCAATTGTCAAGAAAAATTCATTGTATGAAAA
+GACAAAAAAAGAAGGATATGACAACAAAAAATACTGAGAGAAAAGCTGAC
+TGATCTTTTGACTGAATAGATAAAATGTACAATGATTAATCATCATATGG
+ATGTAAGGAGAGAAATAGATGAAAAAACAACGAATGCTCGTACTTTTTAC
+CGCACTATTGTTTGTTTTTACCGGATGTTCACATTCTCCTGAAACAAAAG
+AATCCCCGAAAGAAAAAGCTCAGACACAAAAAGTCTCTTCGGCTTCTGCC
+TCTGAAAAAAAGGATCTGCCAAACATTAGAATTTTAGCGACAGGAGGCAC
+GATAGCTGGTGCCGATCAATCGAAAACCTCAACAACTGAATATAAAGCAG
+GTGTTGTCGGCGTTGAATCACTGATCGAGGCAGTTCCAGAAATGAAGGAC
+ATTGCAAACGTCAGCGGCGAGCAGATTGTTAACGTCGGCAGCACAAATAT
+TGATAATAAAATATTGCTGAAGCTGGCGAAACGCATCAACCACTTGCTCG
+CTTCAGATGATGTAGACGGAATCGTCGTGACTCATGGAACAGATACATTG
+GAGGAAACCGCTTATTTTTTGAATCTTACCGTGAAAAGTGATAAACCGGT
+TGTTATTGTCGGTTCGATGAGACCTTCCACAGCCATCAGCGCTGATGGGC
+CTTCTAACCTGTACAATGCAGTGAAAGTGGCAGGTGCCCCTGAGGCAAAA
+GGGAAAGGGACGCTTGTTGTTCTTAACGACCGGATTGCCTCAGCCCGATA
+TGTCACCAAAACAAACACAACTACAACAGATACATTTAAATCAGAAGAAA
+TGGGCTTCGTCGGAACAATTGCAGATGATATCTATTTTAATAATGAGATT
+ACCCGTAAGCATACGAAGGACACGGATTTCTCGGTTTCTAATCTTGATGA
+GCTGCCGCAGGTTGACATTATCTATGGATACCAAAATGACGGAAGCTACC
+TGTTTGACGCTGCTGTAAAAGCCGGAGCAAAGGGGATTGTATTTGCCGGT
+TCTGGGAACGGGTCTTTATCTGATGCAGCCGAAAAAGGGGCGGACAGCGC
+AGTCAAAAAAGGCGTTACAGTGGTGCGCTCTACCCGCACGGGAAATGGTG
+TCGTCACACCAAACCAAGACTATGCGGAAAAGGACTTGCTGGCATCGAAC
+TCTTTAAACCCCCAAAAAGCACGGATGTTGCTGATGCTTGCGCTTACCAA
+AACAAATGATCCTCAAAAAATCCAAGCTTATTTCAATGAGTATTGAAGAA
+AAGAAGGCGAATAAGCCTTCTTTTTTTTGGCTTTTTAGGACCAATAATGA
+CCTCTGAATCTTAAAATTTCTTTAAAAATAAGCCAAAATTACCCTTTACT
+TAATTAATTTGGTAACGTAATACAATTGGAGAATTTGTTACAAAAAAAGG
+AGGATATTATGAAATTTGTAAAAAGAAGGATCATTGCACTTGTAACAATT
+TTGATGCTGTCTGTTACATCGCTGTTTGCGTTGCAGCCGTCAGCAAAAGC
+CGCTGAACACAATCCAGTCGTTATGGTTCACGGTATTGGAGGGGCATCAT
+TCAATTTTGCGGGAATTAAGAGCTATCTCGTATCTCAGGGCTGGTCGCGG
+GACAAGCTGTATGCAGTTGATTTTTGGGACAAGACAGGCACAAATTATAA
+CAATGGACCGGTATTATCACGATTTGTGCAAAAGGTTTTAGATGAAACGG
+GTGCGAAAAAAGTGGATATTGTCGCTCACAGCATGGGGGGCGCGAACACA
+CTTTACTACATAAAAAATCTGGACGGCGGAAATAAAGTTGCAAACGTCGT
+GACGCTTGGCGGCGCGAACCGTTTGACGACAGGCAAGGCGCTTCCGGGAA
+CAGATCCAAATCAAAAGATTTTATACACATCCATTTACAGCAGTGCCGAT
+ATGATTGTCATGAATTACTTATCAAGATTAGATGGTGCTAGAAACGTTCA
+AATCCATGGCGTTGGACACATCGGCCTTCTGTACAGCAGCCAAGTCAACA
+GCCTGATTAAAGAAGGGCTGAACGGCGGGGGCCAGAATACGAATTAATGA
+AAAACAAAACCTTGAAGAATGCTATTCTTCAAGGTTATTCTGCTTTCAGC
+ACAATGGTTTTCGCAGCCATATCATGAACGGTTTGTTTTTTCTTCGTAAA
+TGCGGCAGTCAAATAGATCAGGCGGGAGAACACATGCACCCACGCTATCA
+GGTAACGGACAATGGCTTGCGGGAAGGATATTTTTTTATATGTTTCGTCC
+CTCACGATTTGCAGCCCGATGATTTTTTTGCCCAGTGTGCCCTTCCAATT
+TGTCAGCGGCATCAGCAAAGGGTACACAATCAGCATCAATATGGCGACAA
+TAATGACACCGGCGGACCCATCGCCAAACGTAAATCCGGCTGCCAAAATC
+ACTGCTGCGGCAATGATTACATCAAGTAAAAGAGCGCAGGCGCGCAGCAT
+GAAACCAGCTAGTTCCAATAGAAACACTCCTTAAAATGTTAAATAAACAC
+CTAATGATTGTAAAAAAGAAGGGCCTAAAGTGGGAATAGGTGATAAGCCT
+TAAATCACAAAAGTTGGTGAAAATGTCATAGGTAAATTGGCATAATCAGC
+CAGCTTATCACATTACCAAATTCTTTTTTAGCCCGAAACCAAGCCCTCAG
+AAGTTATTTTTGTTAAAATAGAAAAGTTACAACAGAATTCGGAGGGTTTA
+TTGTGGGAAAAGTGAAACGAAATGCCCCTTGCCCATGCGGCAGCGGCAAG
+AAATATAAAAAATGCTGCGGAAGTAAAGTTGTCGACTTCCCGGCGGAACT
+AGCGGCAAAAGAAGCGAAACAAATTCAGGAAGACTTAGTGGAGTATGCCT
+TCACAGTACATAGAGAAAGCATTTCAGGCTTTATCAACCAGCATGATTTT
+CTTTCTGCTATGGACAGACAGACGAAAGACATCAGCGTATTTAACTTAGG
+AATCTGGGGAATCTTCTTCCACCCGCTTGCTGGTGAGAAGACAATCTTCG
+AAGAGTACCTTCAGAAAAAAGGCGATTCGATCACTCGTCCGAAAACGCGT
+GAGATCGTAGAATCATGGCAGAGCATGACGCCTGCTTTATTGCTGCTGAA
+GGACCTGAAGGAAGGCATCATTCACTTTGAAGATGTCATTACGGCAAAAC
+AATTCGAAGTGGAAATGGACGCCAGCAATCAAGACCTTCCTCCAGTGGGA
+AGCCTGATTCTTGGATACCCAATCCACGAAGCGGAAAAAGCAGAATTCTT
+CATGCAGTTCACGATCTTCCCGGTGAAGAGAACAGAAGCGCTGATCAGCA
+AGGTGAAGAAATATGCGGATGCCGCTGTGAAGGACGGCAAAACGCCGGAG
+GACTTCATGAAGCAGGAATTCAACAACGTTCTGTTCGCGTTGTTAGCTGA
+GAAAGATGAAGAGCCACAAGCAGAGAAAGCGGAAGTAAGCACTGTTGAGT
+GGGCAAACGACTTGGAGAAAGAAACCGCTGCGGCTATTGAAGAAGGCATG
+AGCGGGGAAGAGTATCCGACTGAATTGATCCCAGCTGTTATTGACATCTG
+GAAAACATTCTGCGAGAAAAAATCACCTGTCATCAGAAAGCCGGAAGCTT
+TTGCGGCGGCAGTTGAATATTATGTAAACGCAATTTCTCTTAACGGCGCG
+TCCGTTTCCCAGGCTAAACTGGCGAAAAAATACGGCGTTAGCGCATCAAC
+GATTTCCAGCCGTTACAAAGAAATTGAAAGCACGCTGCAAGATGAAGCAG
+ATCGTTTTGCACAAGCGTTATCCTCATAATGGAAAAAACCTTGAAAAGCC
+AGGCTTTTCAAGGTTTTTTTATTTCTGAAACGGAATTTTGATTTCTAACC
+GGAAGATGGGGTGGCGGTAGGTAAAATCCAGCCTGCCAAAAGCGCCCTTC
+ACCAGTTTTTGAATGATATATGTGCCCATGCCTTCATGAGCGCCGTTTTT
+CGTTGAGCGGCCAAACGATTGATAAATTGTATCGAGCACTTTTGGGTCCA
+TCCCGGGAGTGCTGTTTTCACAAGTCAGTACATAAAGCCCGCTGCGCAGT
+GAAGTCTCCAGTTTAATCTCTGCTTTTTCTCGGGCCTCCGCCGCGCTGTC
+GAGCGCATTTTCTAATATGTTGCCGACCAAGCTGACCTGATCAGCAGGCG
+AAAACGGAAGGGAAGAAAGCGGTGTATGCATATGCAGCGAAACACTCACA
+TTCGAGGCGCGGGCTTTTTCTAAAAAATCATAAAGCACCCCTGCAACGTA
+CGCGTTCTCTCCTTTCAAAAAACGGTCATATTGGCTGTATTGATCCGCCC
+AGTTTTGAATATATGCTTGTGTATCTGCCTTGGGCTGAGCTGATTTGATT
+GCAGTGATATGTTTCATTGTGTCATGATTCCGGCTTCTGACATCAATCAG
+CATTTGATTGGCGTGCTGTTCAGCTTGAGTCAGCTTATCAATTTGATCAG
+AAAGCCTTGCCTGCAAAGCAGACTGTCCGATACGGAGCCCTTCACACCCT
+GCAAATATCGCGATTACACATAATACCGGCATGATGTCTGTGCCAATCAA
+CACCACTCCCACCGACATCACTTGAATCACCGCAATCCACGCACAAAGCC
+CTGAGGAACAGTGTTTCCACACCCGCTTCGTATTCCAAATGTACAATCCT
+GCAGCAGCTGCGCCTAAAGCAGCGGCGAGCCAAGAGGCGGCTGTGCTGTG
+TGAAAAAGCAGCAGCTCCCTGATAACATATGAAACTAAATAAAATCAGAT
+AAAGACATTGAAAAAGGGTAATCACGTACTAAACTCCTCAAAAATAGTAG
+TTTTGAAAATAATCAAGCTGCTGCTTAGTGATCATCGCTTTTTTAGACGT
+TCCCTCAAAGGAAACTGTGAATGAATGCTTGGTATAAGCGGAAAAATGCT
+TTATGTAATGAATGTTGATAATAAAGGAACGATGCGAACGAAGAAAATCT
+TTTTCGGGCAGGTCGCCTTTAATATCATTTAATGTTTGATACGTTTGCAC
+CTCTTCGGCGGTTGTCACAATCGTCGTCGAACGTCCCGTCCGTTCTGCGA
+AAATAATATCCTTCTTTTGCAGGACGTGCATTTCAGACTTTTGCTTTATC
+AATATACGCCCATTCAAACTCGTTTCCGTTTTCTTTTTCAAGTACCGGTC
+GAAGGAAGCGGCCAGACGGTCGGCATAGTACGGCTTCATAATATAATCAT
+GGACGTTCAGGTCAAAGGCGTGAACCGCATAACCGCCGTGGCCGGTAACA
+AAAATCACATCCACATCAAGTGAATGGGATTTGATCAAATCAGCAAGCTC
+GTAGCCAGACATATGGGGCATCTCGATATCGGCAAGCAGCAGATCAATGT
+CTCCGTTCTTTACCCGCCTGTAGGCTTCCTTCGCTGAATCGGTGGAAAAG
+ACAATTTCGACGTCCTGCATTCTGGACACGATCGCTTCTAACTTCTCTAA
+ATCTACTCGATAATCATCTACAAGTCCGACTTTTACCATTATCATTCCCC
+TAGTTACATAGAATCATCTTTATTCTATCCCATTTCACGACATAAAAAGA
+ACTCTTCGCGACAACTTTATCCAACTAATCCAGCTTTTCGTATATAGTCA
+TTACTAGAAATAAAGATAAGGGAGATTGTGACATGATTACACTGACCGAT
+TGCAGCCGCAGGTTTCAGGATAAGAAAAAAGTAGTCAAAGCGGTGCGAGA
+TGTAAGCTTAACAATTGAAAAAGGAGAAGTCGTCGGCATTCTCGGAGAAA
+ACGGTGCCGGCAAAACGACGATGCTGAGAATGATTGCTTCCTTGCTTGAA
+CCATCACAGGGTGTAATCACAGTAGACGGCTTTGACACGGTCAAGCAGCC
+GGCTGAGGTCAAACAAAGAATCGGTGTCTTATTCGGAGGAGAAACCGGGC
+TTTACGACAGGATGACCGCTAAAGAAAATCTCCAATACTTCGGCAGGCTG
+TATGGGCTGAACCGCCACGAGATCAAAGCAAGAATAGAAGATTTATCGAA
+ACGGTTCGGCATGCGCGATTATATGAACCGGAGAGTGGGCGGGTTTTCGA
+AAGGCATGAGGCAGAAAGTCGCCATTGCCAGAGCGCTGATTCACGATCCG
+GACATCATTTTATTTGATGAGCCGACAACTGGGCTTGATATTACGTCAAG
+CAACATCTTCCGCGAATTTATACAGCAGCTGAAAAGAGAACAAAAAACGA
+TTCTTTTCTCCAGCCACATTATGGAGGAAGTGCAGGCGCTCTGTGACAGT
+GTCATCATGATTCACAGCGGAGAGGTGATTTACCGAGGGGCGCTTGAATC
+ACTATACGAGAGCGAGCGCAGTGAGGATTTGAATTACATCTTTATGTCTA
+AGCTTGTCAGGGGGATTTCTTAAATGCTGAGCCATATTTATAAAAAAGAA
+ATGATCGACGCTTTACGCGACAGAAAAACGATATTACTCACAATCTTAGT
+GCCGATGATTATGATGCTTGGACTTGTCTTTTTTTATGAAAGCATGCTGT
+CCGACAAAGGGGAGCAGTACACGCTGGCTGTCGGCCATTCGCTTCCGCCC
+GCACTGGAAAGCAAGCTTAATGAGATTGACGAAATCAGCGTAAAAACATT
+TGCAAAGCCTGAAGAGGCAGTTGATGAAGGAAAAGCAGATGCCTATCTGA
+ACGTCCCGAAAGAGTTCGACTCATATGTCAACAGCATGACACCTTTTAAG
+GTTGATGTTTACGGCAATTCAATCGATCAAGGGTCGTCAAATGCCATGCA
+GCTTGTGCAGTCTGCCTTAGATCAGTACAAAAATGAAATTGTGCAGCAAC
+GTTTAACAAATAAGCATATTGATCAATCGGTGATCCAGCCGTTTACAATT
+CAGCAAAAGGAAGCGGATGAGGAGAAAGGGACTTCCGCTATTATGCTTTC
+CGCCATTCTGCCCATGCTGATTCTGACTTCCATTGTTTCCGGCGCAATGC
+CGATCGCTCTTGATATCATGGCCGGTGAAAAGGACCGAAAGTCAATCGAG
+GCGCTGCTATTAACGCCAGTCAGCAGAAACAAAGTGCTGGTCGGCAAGTG
+GCTTGCGGTTTCCACTTTTGGCGTGGCTTCAGGTGTATTTGCTTTGGTGT
+TTTTGATTTTGTCCACCGTGTTATTTACCGAAAATTTAAAAACGGCCTTC
+CAGCTGGGAGATCATATGTGGAGTGTAATCGGCGCTTCAGCCTTAATCAT
+TGTGCTCTCTGCATTGCTGATATCTGCGATGGAGCTTTTCATCAGCATCA
+TGTCCAGCTCGGTAAAAGAAGCGCAAAGTTATATGTCTCTCGTCGTCTTT
+CTGCCTGTGTTCCCGATGTTTTTCATCTTCAGCAAGGCACCGAACCAATT
+TGACTTATCATACTTTCTCATCCCGTTTCTGAACCTGCATGCGTTATTTA
+AACAGCTTTTATTCGGGATGGTTGACCCGGCTACCATTTTGTCTACGTCA
+GGAACCATCGCCGTGCTCATCGCCATCTTCTTTTTACTAGCCAGAGCCTG
+CTTCCTGAAAGACAAATGGGTTCTTCCAAAATAAACTTGCGAAAGGAGAA
+ATACACTTTCTCCTTTTTGTATATCCTGAAAAAAGAAGGAAAATAGAAAA
+AGGATATCTAATACAAAAAGTGACCCTGCACTATTTTTCATCAAAATTGG
+TTTCAAAGGAGAAGGAACAATGGATCAAACACGTACACTCGGCAAAACGA
+AGCTGAAGGTGAAGCGGATCGGATTCGGCGCGAATGCGGTCGGCGGGCAT
+AATCTATTTCCAAATCTAAATGATGAAACAGGGAAGGATTTAGTGCGCAC
+GGCATTGGATGGCGGCGTCAATTTTATCGATACCGCCTTTATATATGGAT
+TGGGGCGATCTGAAGAATTAATCGGCGAAGTCGTACAGGAACGCGGCGTG
+CGGAATGAGCTCATCATCGCCACCAAAGGAGCTCATAAAGAAGTGGACGG
+CAGCATTGAATTAGACAATAGCCGGGAGTTTCTTCGCAGCGAGGTGGAGA
+AGAGCCTGAAGCGGCTGAAAACAGATTACATTGATTTGTATTATGTTCAC
+TTTCCGGATGGAAAAACACCTCTCGCTGAAGTGGCGGGCACTTTGAAAGA
+GCTGAAGGATGAGGGGAAAATCAAAGCGATCGGCGCTTCGAACCTCGATT
+ATCAGCAATTGCAGGATTTTAATGCTGACGGCTATTTGGAGGTCTTCCAG
+GCCGAATATTCTCTCATACAGCGTGATGCCGAGAAAGAGCTTCTTCCATA
+CTGTGAAAAACAAGGCATCTCCTTTATTCCTTACTTTCCGCTTGCGTCCG
+GACTGCTGACAGGAAAATTCACGCAAGACACAGTCTTTGATGATTTCAGA
+AAGGATAAACCTCAATTTCAGGGTGAAACGTTTATCCACAATCTCAAAAA
+AGTAGATAAGCTGAAAGCAGTAGCGGAGGAAAAACAAGCGGATACGGCAC
+ATGTCGCCTTGGCGTGGCTGTTAACGAGACCGGCGATTGATGCCATTATT
+CCAGGAGCTAAACGACCGGAGCAATTACAGGATAACCTGAAAACCTTGAA
+CATTGAACTGACCGAAGATGAAGTGAATTTCATCAGCGACATTTTCAAAT
+AAAAAAGGAAATAGCCGTCATGGCTATTTCCTTTTGGTGTTTTATTCTTT
+GATGAATGCTTCGACTAATTCTGCTGCTCTGTAATCATCCATATCAAGCT
+GCCATTGGTCGATGTCATTTTTCTTCATTTTCACTTCAACTGTTTTTTCA
+GATGAAGCAGGTCCAAGCTTTTTGAATTCCTCAGGATAGACTTGAAGCGC
+GTATTTCACTGCCTCTTCATAGCTGGCACTAGAGTTTTTACTGTAGTAGT
+CTTTCACTTTGTCTTCGATGCGGTCTGAAAGAGAAGATGCATCTACAGGT
+TTAACTGTGGCTTCAACAATTGCTTCGTCTTTAGAGATTGAAGTCGTTTT
+TGCTTGAATGGAAGAGTTTTTGCTTAATCCCTCTTTAATGCCGTTCACGA
+TATTATCAAGCGCTTTGCTGTCCGCATATGTGCTGGAAAGGCCGGAAGCT
+GAGAGATAACCGTCTTTGGCTGATTCATTAAAATCATTTACAATTTCATT
+TTTGTTAGCGCCGGTGATTTTTTCGAAATCGGCGTTATCTTTGCCGAAAA
+GAAGGACATCAACATAAGCTGATAACGCTTTTGCAGAATCTTGGAGCTTA
+TCTGCCGTCGCCAGGATTTTTTTGTCTTTTCCGTCAATTTTAAAAGTAAC
+TGATTTTGGCTTTTTATCACCGTAAGATTCCGGCGTATAGTTAAGCTCGT
+ATTGCTTGCCTTTATCTACAACGAAGAAAAGATTTCCTTCAACGGATTTG
+TCAGCGTTAATCGTGCTGCCCTGAAGCTTTTCGCTATAGTCTTCAGGGTC
+TGTGTCAGACATTTTGGTATCACCTTGATACAATGTGAAATCCATACTGT
+CTACATTCAGCGGGTCTTTTCCTGTGTTTTTCACCGCGACATTGACTTTT
+AACACAAGCTGGTCATCTGAAGTGGACTTATCATATTTAGACGGAAGTGT
+GTAAGAGACATCCTTGATTTTGACTTGAGCTATATCTGAGCTTTTTTCTG
+TTTCTGATTCTTTCTTCTCCGCGCTTGTTTTGCTGCCGGAACAAGCAGCT

src/prokov/lxpack/tests/diff.csh

@@ -0,0 +1,65 @@
+#!/bin/csh -f
+#
+# diff for prokov tests
+# (avoid errors due to rounding floats)
+
+if ($#argv != 2) exit 1
+
+if (! -e $1) exit 3
+if (! -e $2) exit 3
+
+sed -e 's/\.\(..\)[0-4][0-9]*/\.\1/g' $1 |\
+sed -e 's/\.\(.\)0[5-9][0-9]*/\.\11/g'   |\
+sed -e 's/\.\(.\)1[5-9][0-9]*/\.\12/g'   |\
+sed -e 's/\.\(.\)2[5-9][0-9]*/\.\13/g'   |\
+sed -e 's/\.\(.\)3[5-9][0-9]*/\.\14/g'   |\
+sed -e 's/\.\(.\)4[5-9][0-9]*/\.\15/g'   |\
+sed -e 's/\.\(.\)5[5-9][0-9]*/\.\16/g'   |\
+sed -e 's/\.\(.\)6[5-9][0-9]*/\.\17/g'   |\
+sed -e 's/\.\(.\)7[5-9][0-9]*/\.\18/g'   |\
+sed -e 's/\.\(.\)8[5-9][0-9]*/\.\19/g'   |\
+sed -e 's/\.09[5-9][0-9]*/\.10/g'   |\
+sed -e 's/\.19[5-9][0-9]*/\.20/g'   |\
+sed -e 's/\.29[5-9][0-9]*/\.30/g'   |\
+sed -e 's/\.39[5-9][0-9]*/\.40/g'   |\
+sed -e 's/\.49[5-9][0-9]*/\.50/g'   |\
+sed -e 's/\.59[5-9][0-9]*/\.60/g'   |\
+sed -e 's/\.69[5-9][0-9]*/\.70/g'   |\
+sed -e 's/\.79[5-9][0-9]*/\.80/g'   |\
+sed -e 's/\.89[5-9][0-9]*/\.90/g'   |\
+sed -e 's/0\.99[5-9][0-9]*/1\.00/g' > 1_$$
+
+sed -e 's/\.\(..\)[0-4][0-9]*/\.\1/g' $2 |\
+sed -e 's/\.\(.\)0[5-9][0-9]*/\.\11/g'   |\
+sed -e 's/\.\(.\)1[5-9][0-9]*/\.\12/g'   |\
+sed -e 's/\.\(.\)2[5-9][0-9]*/\.\13/g'   |\
+sed -e 's/\.\(.\)3[5-9][0-9]*/\.\14/g'   |\
+sed -e 's/\.\(.\)4[5-9][0-9]*/\.\15/g'   |\
+sed -e 's/\.\(.\)5[5-9][0-9]*/\.\16/g'   |\
+sed -e 's/\.\(.\)6[5-9][0-9]*/\.\17/g'   |\
+sed -e 's/\.\(.\)7[5-9][0-9]*/\.\18/g'   |\
+sed -e 's/\.\(.\)8[5-9][0-9]*/\.\19/g'   |\
+sed -e 's/\.09[5-9][0-9]*/\.10/g'   |\
+sed -e 's/\.19[5-9][0-9]*/\.20/g'   |\
+sed -e 's/\.29[5-9][0-9]*/\.30/g'   |\
+sed -e 's/\.39[5-9][0-9]*/\.40/g'   |\
+sed -e 's/\.49[5-9][0-9]*/\.50/g'   |\
+sed -e 's/\.59[5-9][0-9]*/\.60/g'   |\
+sed -e 's/\.69[5-9][0-9]*/\.70/g'   |\
+sed -e 's/\.79[5-9][0-9]*/\.80/g'   |\
+sed -e 's/\.89[5-9][0-9]*/\.90/g'   |\
+sed -e 's/0\.99[5-9][0-9]*/1\.00/g' > 2_$$
+
+diff 1_$$ 2_$$
+
+set stat = $status
+
+#
+# fin
+#
+
+fin:
+
+\rm -f ?_$$
+
+exit $stat

src/prokov/lxpack/tests/test.ascii.mat.ref

@@ -0,0 +1,513 @@
+v1.2 4 4 256 256
+2494	2768	2676	
+1146	1228	1125	
+2701	704	1178	
+958	1683	1135	
+853	960	1022	
+491	357	449	
+857	498	782	
+420	564	353	
+728	2577	541	
+1065	1515	752	
+1030	1192	214	
+335	1010	316	
+887	688	385	
+699	597	1034	
+1315	370	1033	
+452	1023	1119	
+1011	882	730	
+512	422	223	
+1161	575	662	
+528	856	407	
+347	470	210	
+169	307	71	
+507	444	391	
+261	383	223	
+774	806	202	
+478	494	256	
+658	1026	247	
+344	431	215	
+165	285	178	
+198	247	268	
+700	224	593	
+268	587	474	
+612	924	2214	
+246	343	845	
+518	224	1098	
+191	600	1175	
+613	1031	971	
+406	534	593	
+593	464	949	
+441	1459	668	
+150	1355	752	
+205	623	926	
+169	433	520	
+84	573	412	
+208	303	462	
+145	266	548	
+449	152	657	
+190	407	489	
+341	1252	125	
+255	765	522	
+420	166	29	
+320	1462	848	
+1464	1130	620	
+569	696	276	
+1472	314	292	
+387	665	423	
+1421	2189	66	
+784	1020	187	
+1229	646	495	
+533	1103	132	
+1191	606	724	
+1098	582	516	
+2043	269	664	
+1151	1269	1121	
+1269	1331	1301	
+155	504	490	
+928	510	517	
+597	813	806	
+341	434	623	
+222	294	312	
+363	143	400	
+215	478	293	
+508	1179	494	
+1119	895	827	
+854	741	205	
+337	656	344	
+598	351	317	
+496	446	960	
+712	190	831	
+505	843	1466	
+436	458	492	
+55	182	210	
+357	215	441	
+261	639	460	
+85	246	175	
+73	106	82	
+257	193	431	
+71	230	288	
+756	487	164	
+582	486	520	
+713	702	280	
+320	403	371	
+233	224	125	
+220	205	248	
+754	120	520	
+385	410	543	
+301	918	946	
+40	453	403	
+166	245	559	
+143	1086	781	
+397	415	550	
+316	440	508	
+352	181	466	
+305	916	614	
+309	900	1219	
+264	691	1382	
+331	481	572	
+123	569	777	
+213	293	375	
+230	253	516	
+412	118	441	
+321	576	617	
+275	504	36	
+48	217	350	
+192	84	9	
+224	411	745	
+503	439	355	
+250	275	220	
+680	119	173	
+215	355	313	
+1190	1402	27	
+905	794	202	
+762	403	383	
+576	946	174	
+457	378	430	
+732	544	430	
+1568	168	376	
+737	709	944	
+2620	895	1846	
+1078	381	515	
+2665	289	890	
+1123	578	792	
+939	303	785	
+577	90	240	
+923	160	532	
+421	218	338	
+855	721	368	
+1304	362	335	
+1100	299	129	
+456	254	202	
+1300	194	307	
+910	166	901	
+1801	104	850	
+1002	422	1539	
+1004	676	739	
+477	406	312	
+1188	381	834	
+587	800	663	
+723	453	312	
+351	206	124	
+922	340	797	
+354	434	557	
+893	549	141	
+675	441	333	
+1013	914	320	
+403	419	321	
+395	375	224	
+422	284	651	
+1333	286	1679	
+720	587	1661	
+1230	534	1541	
+485	260	574	
+952	174	758	
+552	538	1105	
+1074	356	798	
+549	182	359	
+1178	156	673	
+648	592	720	
+525	575	580	
+471	333	489	
+459	261	320	
+242	287	273	
+357	160	314	
+260	135	405	
+808	70	593	
+455	330	653	
+682	283	60	
+285	197	374	
+512	28	10	
+499	408	711	
+1102	201	421	
+315	189	193	
+780	45	164	
+327	306	405	
+943	867	27	
+706	369	120	
+536	106	294	
+477	530	79	
+511	183	419	
+665	278	422	
+1011	40	206	
+636	573	1166	
+0	1120	1476	
+0	493	491	
+0	320	573	
+0	497	620	
+602	325	782	
+314	154	283	
+614	119	540	
+287	253	347	
+0	855	164	
+0	409	139	
+0	378	60	
+0	236	130	
+860	291	327	
+700	402	997	
+1130	216	851	
+767	737	1358	
+707	1098	988	
+305	618	396	
+765	699	881	
+454	1279	781	
+339	434	412	
+182	357	209	
+392	358	752	
+273	389	524	
+279	847	143	
+217	717	261	
+257	1308	180	
+173	696	269	
+423	256	212	
+348	325	481	
+758	156	641	
+426	596	816	
+0	1667	2785	
+0	839	1038	
+0	391	1300	
+0	1373	1952	
+179	746	937	
+162	634	890	
+200	314	896	
+138	1248	868	
+522	1148	668	
+346	903	652	
+497	487	285	
+246	536	418	
+138	399	827	
+106	529	1055	
+203	180	928	
+108	900	1064	
+1132	1121	68	
+263	773	571	
+754	215	17	
+603	1252	1153	
+625	1276	835	
+404	737	497	
+636	375	297	
+404	824	814	
+716	2617	26	
+547	1408	170	
+547	868	439	
+422	1295	170	
+1202	642	1179	
+717	1039	701	
+1566	328	932	
+1010	1525	1264	
+1956
+979
+1162
+1219
+817
+455
+608
+403
+947
+1050
+629
+498
+803
+882
+922
+864
+751
+373
+682
+593
+371
+224
+468
+322
+486
+395
+504
+330
+165
+270
+475
+498
+965
+412
+453
+573
+811
+582
+640
+856
+573
+516
+285
+322
+310
+322
+374
+403
+787
+526
+332
+876
+1089
+622
+681
+573
+1031
+673
+621
+593
+606
+781
+865
+1219
+1121
+401
+677
+865
+451
+383
+312
+374
+622
+1023
+532
+475
+577
+776
+577
+922
+540
+230
+426
+621
+295
+216
+377
+285
+525
+639
+565
+504
+170
+366
+532
+629
+578
+314
+323
+681
+462
+545
+333
+640
+655
+732
+377
+468
+359
+435
+312
+608
+300
+194
+95
+332
+498
+438
+323
+453
+827
+717
+426
+682
+359
+925
+677
+1162
+1303
+556
+925
+781
+619
+284
+435
+322
+516
+559
+366
+270
+650
+659
+776
+882
+757
+398
+717
+673
+564
+329
+732
+516
+463
+483
+639
+395
+257
+559
+1023
+1050
+823
+336
+438
+622
+652
+363
+545
+582
+404
+329
+216
+224
+263
+284
+383
+455
+438
+285
+194
+526
+600
+336
+314
+412
+526
+398
+230
+373
+349
+556
+401
+979
+936
+349
+359
+606
+512
+263
+359
+310
+318
+257
+170
+165
+492
+650
+577
+803
+1025
+526
+827
+1031
+587
+404
+655
+573
+423
+463
+525
+486
+318
+516
+622
+947
+1198
+600
+498
+1089
+620
+652
+462
+811
+587
+564
+295
+371
+512
+619
+451
+817
+773
+438
+300
+787
+1198
+823
+578
+965
+1025
+757
+540
+751
+936
+1303
+1121
+1956

src/prokov/lxpack/tests/test.cds.ref

@@ -0,0 +1,10 @@
+BASU_CDS_470_1597_D 470 1597 +2 1.000 max 0
+BASU_CDS_1727_2398_D 1727 2398 +2 1.000 max 0
+BASU_CDS_5984_6724_D 5984 6724 +2 1.000 max 0
+BASU_CDS_6725_7885_D 6725 7885 +2 1.000 max 0
+BASU_CDS_8021_8953_D 8021 8953 +2 1.000 max 0
+BASU_CDS_3054_4130_D 3054 4130 +3 1.000 max 0
+BASU_CDS_5139_5846_C 5139 5846 -3 1.000 max 0
+BASU_CDS_4170_5126_C 4170 5126 -3 1.000 max 0
+BASU_CDS_2436_2828_C 2436 2828 -3 1.000 max 0
+BASU_CDS_8993_9856_C 8993 9856 -2 1.000 max 0

src/prokov/lxpack/tests/test.csh

@@ -0,0 +1,131 @@
+#!/bin/csh -f
+#
+# prokov tests
+#
+
+#
+# learn
+#
+
+set test = "learning - 1"
+echo "test: $test"
+
+../src/prokov_learn -a -k 4 -o test.ascii.mat.bak bacil.learn
+
+diff test.ascii.mat.bak test.ascii.mat.ref
+if ($status != 0) goto failure
+
+set test = "learning - 2"
+echo "test: $test"
+
+../src/prokov_learn -k 4 -o test.bin.mat.bak bacil.learn
+diff test.bin.mat.bak test.bin.mat.ref
+if ($status != 0) goto failure
+
+set test = "learning - 3"
+echo "test: $test"
+
+../src/prokov_learn -k 4 -K 2 -o test.bin.hol.mat.bak bacil.learn bacil.holes
+diff test.bin.hol.mat.bak test.bin.hol.mat.ref
+if ($status != 0) goto failure
+
+
+#
+# score
+#
+
+set test = "scoring - 1"
+echo "test: $test"
+
+../src/prokov_score -m test.bin.mat.ref bacil.check > ! test.score.bak
+./diff.csh test.score.bak test.score.ref
+if ($status != 0) goto failure
+
+
+#
+# curve
+#
+
+set test = "curve - 1"
+echo "test: $test"
+
+../src/prokov_curve -m test.bin.mat.ref bacil.test > ! test.curve.bak
+./diff.csh test.curve.bak test.curve.ref
+if ($status != 0) goto failure
+
+#
+# curve frame tests
+#
+
+set test = "curve - 2"
+echo -n "test: $test "
+
+foreach f (*S*.fasta)
+   echo -n "$f:r "
+   ../src/prokov_curve -m test.bin.mat.ref $f > ! $f:r.curve.bak
+  ./diff.csh $f:r.curve.bak $f:r.curve.ref
+  if ($status != 0) goto failure
+end
+
+echo ""
+
+#
+# cds
+#
+
+set test = "cds - 1"
+echo "test: $test"
+
+../src/prokov_cds -m test.bin.mat.ref bacil.test > ! test.cds.bak
+./diff.csh test.cds.bak test.cds.ref
+if ($status != 0) goto failure
+
+#
+# test environnement
+#
+
+set test = "envir - 1"
+echo "test: $test"
+
+mkdir TEST_MAT
+cp test.bin.mat.ref TEST_MAT/toto
+setenv PROKOV_MATDIR ./TEST_MAT
+../src/prokov_cds -m toto bacil.test > ! test.cds.bak
+if ($status != 0) goto failure
+
+#
+# Success
+#
+
+echo " "
+echo " All tests were succesfull "
+echo " "
+
+set stat = 0
+
+goto fin
+
+#
+# Failure
+#
+
+failure:
+
+echo "--------------------------------------------------"
+echo " ! FAILURE at Test $test"
+echo "--------------------------------------------------"
+
+set stat = 1
+
+goto fin
+
+#
+# fin
+#
+
+fin:
+
+if ($stat == 0) \rm -f *.bak
+\rm -r TEST_MAT
+
+exit $stat

src/prokov/lxpack/tests/test.curve.ref

@@ -0,0 +1,330 @@
+    61	0.000	0.001	0.000	0.000	0.996	0.000	0.003
+    91	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   121	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+   151	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+   181	0.000	0.000	0.000	0.000	0.973	0.000	0.027
+   211	0.001	0.001	0.000	0.005	0.019	0.000	0.974
+   241	0.001	0.001	0.000	0.000	0.001	0.000	0.997
+   271	0.000	0.016	0.000	0.000	0.000	0.000	0.984
+   301	0.000	0.065	0.000	0.000	0.000	0.000	0.935
+   331	0.000	0.211	0.043	0.000	0.000	0.000	0.746
+   361	0.001	0.001	0.000	0.000	0.000	0.000	0.998
+   391	0.000	0.000	0.001	0.000	0.000	0.003	0.996
+   421	0.004	0.000	0.000	0.000	0.000	0.001	0.995
+   451	0.232	0.000	0.000	0.000	0.000	0.001	0.767
+   481	0.017	0.000	0.000	0.000	0.000	0.059	0.924
+   511	0.000	0.062	0.000	0.000	0.000	0.028	0.910
+   541	0.000	0.592	0.005	0.000	0.000	0.000	0.403
+   571	0.000	0.778	0.009	0.000	0.000	0.000	0.213
+   601	0.000	0.997	0.000	0.000	0.000	0.000	0.003
+   631	0.000	0.971	0.000	0.000	0.000	0.000	0.029
+   661	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+   691	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   721	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   751	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   781	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   811	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   841	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+   871	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+   901	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+   931	0.000	0.979	0.000	0.000	0.000	0.000	0.021
+   961	0.000	0.964	0.000	0.000	0.000	0.000	0.036
+   991	0.000	0.955	0.000	0.000	0.000	0.040	0.006
+  1021	0.000	0.982	0.000	0.000	0.000	0.015	0.003
+  1051	0.000	0.997	0.000	0.000	0.000	0.000	0.002
+  1081	0.000	0.999	0.000	0.000	0.000	0.001	0.001
+  1111	0.000	0.989	0.000	0.000	0.000	0.009	0.002
+  1141	0.000	0.997	0.000	0.000	0.000	0.000	0.003
+  1171	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  1201	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  1231	0.000	0.999	0.000	0.000	0.000	0.000	0.000
+  1261	0.000	0.998	0.000	0.000	0.001	0.000	0.001
+  1291	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  1321	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  1351	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  1381	0.000	0.994	0.000	0.000	0.000	0.004	0.002
+  1411	0.000	0.980	0.000	0.000	0.000	0.018	0.003
+  1441	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  1471	0.000	0.994	0.000	0.000	0.000	0.001	0.005
+  1501	0.000	0.998	0.000	0.000	0.000	0.000	0.002
+  1531	0.000	0.986	0.000	0.000	0.000	0.000	0.013
+  1561	0.000	0.108	0.000	0.000	0.000	0.000	0.892
+  1591	0.000	0.001	0.001	0.000	0.035	0.000	0.963
+  1621	0.000	0.000	0.000	0.000	0.000	0.000	1.000
+  1651	0.000	0.000	0.000	0.000	0.000	0.000	1.000
+  1681	0.001	0.000	0.000	0.000	0.000	0.000	0.999
+  1711	0.011	0.364	0.000	0.000	0.000	0.000	0.626
+  1741	0.005	0.508	0.000	0.000	0.000	0.000	0.486
+  1771	0.001	0.953	0.000	0.000	0.000	0.000	0.046
+  1801	0.000	0.983	0.000	0.000	0.000	0.000	0.017
+  1831	0.000	0.915	0.000	0.000	0.000	0.000	0.085
+  1861	0.000	0.935	0.000	0.000	0.000	0.000	0.065
+  1891	0.000	0.875	0.001	0.000	0.000	0.000	0.124
+  1921	0.000	0.991	0.000	0.000	0.000	0.000	0.009
+  1951	0.000	0.952	0.004	0.000	0.000	0.000	0.044
+  1981	0.002	0.911	0.000	0.000	0.000	0.000	0.087
+  2011	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  2041	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  2071	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  2101	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  2131	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  2161	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  2191	0.000	0.998	0.000	0.000	0.000	0.000	0.002
+  2221	0.000	0.982	0.000	0.000	0.000	0.000	0.018
+  2251	0.000	0.963	0.000	0.000	0.000	0.000	0.037
+  2281	0.000	0.892	0.000	0.000	0.000	0.000	0.108
+  2311	0.000	0.998	0.000	0.000	0.000	0.000	0.002
+  2341	0.000	0.949	0.000	0.000	0.009	0.000	0.042
+  2371	0.001	0.016	0.000	0.000	0.000	0.000	0.983
+  2401	0.006	0.008	0.000	0.000	0.000	0.000	0.986
+  2431	0.004	0.000	0.106	0.000	0.000	0.000	0.890
+  2461	0.000	0.000	0.025	0.000	0.000	0.000	0.974
+  2491	0.000	0.000	0.001	0.734	0.000	0.000	0.265
+  2521	0.000	0.000	0.001	0.990	0.000	0.000	0.009
+  2551	0.000	0.000	0.000	0.958	0.000	0.000	0.042
+  2581	0.000	0.000	0.000	0.993	0.000	0.000	0.007
+  2611	0.000	0.000	0.000	0.988	0.000	0.000	0.012
+  2641	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  2671	0.000	0.000	0.000	0.998	0.000	0.000	0.002
+  2701	0.018	0.000	0.000	0.976	0.000	0.000	0.006
+  2731	0.028	0.000	0.000	0.961	0.000	0.000	0.011
+  2761	0.006	0.000	0.000	0.959	0.000	0.000	0.035
+  2791	0.003	0.000	0.000	0.032	0.000	0.000	0.964
+  2821	0.008	0.020	0.000	0.011	0.000	0.000	0.961
+  2851	0.011	0.026	0.000	0.000	0.000	0.027	0.937
+  2881	0.249	0.008	0.000	0.000	0.000	0.099	0.644
+  2911	0.908	0.001	0.000	0.000	0.000	0.000	0.092
+  2941	0.004	0.002	0.000	0.000	0.000	0.000	0.994
+  2971	0.020	0.001	0.000	0.000	0.000	0.000	0.980
+  3001	0.001	0.001	0.061	0.000	0.000	0.000	0.937
+  3031	0.000	0.000	0.022	0.000	0.000	0.000	0.977
+  3061	0.058	0.000	0.010	0.002	0.000	0.000	0.929
+  3091	0.000	0.000	0.909	0.000	0.000	0.000	0.090
+  3121	0.000	0.000	0.939	0.000	0.000	0.000	0.061
+  3151	0.000	0.000	0.998	0.000	0.000	0.000	0.002
+  3181	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+  3211	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+  3241	0.000	0.000	0.998	0.000	0.000	0.000	0.002
+  3271	0.000	0.000	0.990	0.000	0.000	0.000	0.009
+  3301	0.000	0.000	0.989	0.000	0.000	0.000	0.011
+  3331	0.000	0.000	0.982	0.000	0.000	0.000	0.018
+  3361	0.000	0.000	0.941	0.000	0.000	0.000	0.059
+  3391	0.000	0.000	0.976	0.000	0.000	0.000	0.024
+  3421	0.000	0.000	0.997	0.000	0.000	0.000	0.003
+  3451	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+  3481	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+  3511	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+  3541	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+  3571	0.000	0.000	0.949	0.002	0.000	0.000	0.049
+  3601	0.000	0.001	0.947	0.001	0.000	0.000	0.051
+  3631	0.000	0.000	0.992	0.000	0.000	0.000	0.007
+  3661	0.000	0.016	0.978	0.000	0.000	0.000	0.006
+  3691	0.000	0.000	0.995	0.000	0.000	0.000	0.004
+  3721	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+  3751	0.000	0.000	0.999	0.000	0.000	0.000	0.001
+  3781	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+  3811	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+  3841	0.000	0.000	1.000	0.000	0.000	0.000	0.000
+  3871	0.000	0.000	0.996	0.000	0.000	0.000	0.004
+  3901	0.000	0.000	0.980	0.000	0.000	0.000	0.019
+  3931	0.000	0.000	0.888	0.000	0.000	0.000	0.112
+  3961	0.000	0.000	0.826	0.000	0.003	0.000	0.171
+  3991	0.000	0.000	0.976	0.000	0.005	0.000	0.019
+  4021	0.000	0.000	0.998	0.000	0.000	0.000	0.002
+  4051	0.000	0.000	0.997	0.000	0.000	0.000	0.003
+  4081	0.000	0.000	0.973	0.000	0.000	0.000	0.027
+  4111	0.012	0.000	0.026	0.000	0.000	0.000	0.961
+  4141	0.006	0.000	0.000	0.000	0.000	0.000	0.994
+  4171	0.000	0.000	0.000	0.000	0.000	0.000	0.999
+  4201	0.000	0.000	0.001	0.011	0.000	0.000	0.988
+  4231	0.000	0.000	0.001	0.985	0.000	0.000	0.014
+  4261	0.000	0.000	0.000	0.977	0.000	0.000	0.023
+  4291	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  4321	0.000	0.000	0.000	0.998	0.000	0.000	0.002
+  4351	0.000	0.000	0.000	0.978	0.000	0.000	0.022
+  4381	0.000	0.000	0.000	0.994	0.000	0.000	0.006
+  4411	0.001	0.000	0.000	0.975	0.000	0.000	0.024
+  4441	0.000	0.000	0.000	0.997	0.000	0.000	0.003
+  4471	0.000	0.000	0.000	0.985	0.000	0.000	0.015
+  4501	0.002	0.000	0.000	0.949	0.000	0.000	0.049
+  4531	0.000	0.000	0.000	0.977	0.000	0.000	0.023
+  4561	0.000	0.000	0.000	0.994	0.000	0.000	0.005
+  4591	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  4621	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  4651	0.000	0.000	0.000	0.986	0.000	0.000	0.014
+  4681	0.000	0.000	0.000	0.782	0.000	0.000	0.218
+  4711	0.000	0.000	0.001	0.707	0.000	0.000	0.292
+  4741	0.000	0.000	0.005	0.932	0.000	0.000	0.063
+  4771	0.000	0.000	0.002	0.990	0.000	0.000	0.009
+  4801	0.000	0.005	0.000	0.989	0.000	0.000	0.006
+  4831	0.000	0.000	0.000	0.989	0.000	0.000	0.011
+  4861	0.021	0.000	0.000	0.894	0.000	0.000	0.085
+  4891	0.000	0.000	0.000	0.982	0.000	0.000	0.018
+  4921	0.000	0.000	0.000	0.937	0.000	0.016	0.047
+  4951	0.000	0.000	0.000	0.877	0.000	0.011	0.112
+  4981	0.003	0.000	0.000	0.838	0.000	0.000	0.159
+  5011	0.268	0.000	0.000	0.058	0.001	0.000	0.673
+  5041	0.072	0.000	0.000	0.029	0.000	0.000	0.899
+  5071	0.000	0.000	0.000	0.018	0.000	0.000	0.982
+  5101	0.000	0.001	0.000	0.000	0.000	0.000	0.999
+  5131	0.000	0.000	0.006	0.000	0.000	0.000	0.994
+  5161	0.000	0.000	0.061	0.001	0.000	0.000	0.938
+  5191	0.000	0.000	0.018	0.134	0.000	0.000	0.848
+  5221	0.000	0.000	0.009	0.980	0.000	0.000	0.012
+  5251	0.000	0.000	0.263	0.324	0.000	0.000	0.413
+  5281	0.000	0.000	0.026	0.703	0.000	0.000	0.272
+  5311	0.000	0.000	0.000	0.991	0.000	0.000	0.009
+  5341	0.000	0.000	0.000	0.992	0.000	0.000	0.008
+  5371	0.000	0.000	0.000	1.000	0.000	0.000	0.000
+  5401	0.000	0.000	0.000	0.960	0.000	0.001	0.040
+  5431	0.000	0.000	0.000	0.211	0.000	0.662	0.128
+  5461	0.000	0.000	0.076	0.165	0.000	0.090	0.669
+  5491	0.000	0.000	0.008	0.776	0.000	0.000	0.216
+  5521	0.000	0.000	0.044	0.931	0.000	0.000	0.025
+  5551	0.000	0.000	0.024	0.974	0.000	0.000	0.001
+  5581	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  5611	0.000	0.000	0.004	0.995	0.000	0.000	0.001
+  5641	0.000	0.000	0.001	0.999	0.000	0.000	0.000
+  5671	0.000	0.000	0.002	0.997	0.000	0.000	0.001
+  5701	0.000	0.000	0.002	0.996	0.000	0.000	0.002
+  5731	0.000	0.000	0.000	0.999	0.000	0.000	0.001
+  5761	0.000	0.000	0.000	0.998	0.000	0.000	0.002
+  5791	0.000	0.000	0.000	0.999	0.000	0.000	0.000
+  5821	0.019	0.000	0.000	0.004	0.000	0.000	0.977
+  5851	0.001	0.000	0.000	0.000	0.000	0.000	0.999
+  5881	0.011	0.000	0.000	0.000	0.000	0.000	0.988
+  5911	0.000	0.002	0.000	0.000	0.000	0.001	0.998
+  5941	0.000	0.295	0.000	0.000	0.000	0.009	0.696
+  5971	0.000	0.270	0.000	0.000	0.000	0.000	0.730
+  6001	0.000	0.971	0.000	0.000	0.016	0.000	0.013
+  6031	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  6061	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6091	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6121	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6151	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6181	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  6211	0.000	0.996	0.000	0.000	0.000	0.000	0.004
+  6241	0.000	0.994	0.000	0.000	0.000	0.000	0.006
+  6271	0.000	0.993	0.000	0.000	0.000	0.000	0.007
+  6301	0.000	0.984	0.000	0.000	0.000	0.000	0.016
+  6331	0.000	0.992	0.000	0.000	0.000	0.000	0.008
+  6361	0.000	0.995	0.000	0.000	0.000	0.000	0.005
+  6391	0.000	0.996	0.000	0.000	0.000	0.000	0.004
+  6421	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6451	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6481	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6511	0.000	0.997	0.000	0.000	0.000	0.000	0.003
+  6541	0.000	0.985	0.000	0.000	0.000	0.000	0.015
+  6571	0.000	0.996	0.000	0.000	0.002	0.000	0.002
+  6601	0.000	0.998	0.000	0.000	0.000	0.000	0.002
+  6631	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  6661	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6691	0.000	0.989	0.000	0.000	0.000	0.000	0.011
+  6721	0.000	0.945	0.000	0.000	0.000	0.000	0.055
+  6751	0.000	0.917	0.000	0.000	0.000	0.000	0.083
+  6781	0.000	0.863	0.000	0.000	0.000	0.000	0.137
+  6811	0.000	0.963	0.000	0.000	0.000	0.000	0.037
+  6841	0.000	0.992	0.000	0.000	0.000	0.000	0.008
+  6871	0.000	0.997	0.000	0.000	0.001	0.000	0.003
+  6901	0.000	0.993	0.000	0.000	0.000	0.001	0.005
+  6931	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6961	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  6991	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  7021	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  7051	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  7081	0.000	0.998	0.000	0.000	0.000	0.000	0.002
+  7111	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  7141	0.000	0.998	0.000	0.000	0.000	0.000	0.002
+  7171	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  7201	0.000	0.997	0.000	0.000	0.000	0.000	0.003
+  7231	0.000	0.971	0.000	0.000	0.000	0.000	0.029
+  7261	0.000	0.992	0.000	0.000	0.000	0.000	0.008
+  7291	0.000	0.671	0.000	0.000	0.000	0.310	0.019
+  7321	0.000	0.937	0.000	0.000	0.000	0.052	0.011
+  7351	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  7381	0.000	0.997	0.000	0.000	0.000	0.001	0.003
+  7411	0.000	0.885	0.000	0.000	0.000	0.090	0.026
+  7441	0.000	0.888	0.000	0.000	0.000	0.084	0.028
+  7471	0.000	0.849	0.000	0.000	0.000	0.001	0.150
+  7501	0.000	0.936	0.000	0.000	0.000	0.000	0.064
+  7531	0.000	0.984	0.000	0.000	0.000	0.000	0.016
+  7561	0.000	0.975	0.000	0.000	0.000	0.002	0.023
+  7591	0.000	0.866	0.000	0.000	0.000	0.010	0.125
+  7621	0.000	0.735	0.000	0.000	0.003	0.006	0.255
+  7651	0.001	0.691	0.000	0.000	0.000	0.005	0.303
+  7681	0.000	0.566	0.000	0.000	0.000	0.000	0.433
+  7711	0.000	0.848	0.000	0.000	0.000	0.048	0.104
+  7741	0.000	0.971	0.000	0.000	0.000	0.016	0.013
+  7771	0.000	0.976	0.000	0.000	0.000	0.014	0.010
+  7801	0.000	0.776	0.000	0.000	0.000	0.167	0.057
+  7831	0.000	0.054	0.000	0.000	0.000	0.502	0.443
+  7861	0.000	0.001	0.000	0.000	0.000	0.131	0.868
+  7891	0.038	0.000	0.000	0.001	0.000	0.014	0.947
+  7921	0.000	0.000	0.308	0.000	0.000	0.098	0.594
+  7951	0.000	0.000	0.312	0.000	0.000	0.096	0.592
+  7981	0.000	0.017	0.480	0.000	0.000	0.000	0.503
+  8011	0.000	0.973	0.000	0.000	0.000	0.000	0.027
+  8041	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8071	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8101	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8131	0.000	0.998	0.000	0.000	0.000	0.000	0.002
+  8161	0.000	0.928	0.000	0.000	0.000	0.000	0.072
+  8191	0.000	0.997	0.000	0.000	0.000	0.000	0.003
+  8221	0.000	0.995	0.000	0.000	0.000	0.000	0.005
+  8251	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  8281	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  8311	0.000	0.974	0.000	0.000	0.000	0.000	0.026
+  8341	0.000	0.997	0.000	0.000	0.000	0.000	0.003
+  8371	0.000	0.967	0.000	0.000	0.000	0.000	0.033
+  8401	0.000	0.999	0.000	0.000	0.000	0.000	0.001
+  8431	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8461	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8491	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8521	0.000	0.996	0.000	0.000	0.002	0.000	0.001
+  8551	0.000	0.816	0.000	0.000	0.174	0.000	0.010
+  8581	0.000	0.801	0.000	0.000	0.188	0.000	0.011
+  8611	0.000	0.993	0.000	0.000	0.002	0.000	0.005
+  8641	0.000	0.994	0.000	0.000	0.002	0.000	0.004
+  8671	0.000	0.996	0.000	0.000	0.000	0.000	0.003
+  8701	0.000	0.997	0.000	0.000	0.002	0.000	0.001
+  8731	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8761	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8791	0.000	1.000	0.000	0.000	0.000	0.000	0.000
+  8821	0.000	0.997	0.000	0.000	0.000	0.000	0.003
+  8851	0.000	0.993	0.000	0.000	0.000	0.000	0.007
+  8881	0.000	0.994	0.000	0.000	0.000	0.000	0.006
+  8911	0.000	0.008	0.000	0.000	0.000	0.000	0.991
+  8941	0.000	0.008	0.000	0.000	0.000	0.022	0.970
+  8971	0.000	0.000	0.001	0.000	0.000	0.002	0.997
+  9001	0.000	0.000	0.000	0.000	0.000	0.006	0.994
+  9031	0.000	0.001	0.000	0.000	0.003	0.000	0.996
+  9061	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9091	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9121	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9151	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9181	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9211	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9241	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9271	0.000	0.000	0.006	0.000	0.992	0.000	0.002
+  9301	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9331	0.000	0.000	0.000	0.000	0.999	0.000	0.000
+  9361	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  9391	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9421	0.000	0.000	0.001	0.000	0.993	0.000	0.006
+  9451	0.000	0.000	0.000	0.000	0.992	0.000	0.008
+  9481	0.000	0.000	0.000	0.000	0.998	0.000	0.002
+  9511	0.000	0.000	0.000	0.000	0.997	0.000	0.003
+  9541	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  9571	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  9601	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9631	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9661	0.000	0.000	0.000	0.000	0.998	0.000	0.002
+  9691	0.000	0.000	0.000	0.000	0.999	0.000	0.000
+  9721	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  9751	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  9781	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9811	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9841	0.000	0.000	0.001	0.000	0.999	0.000	0.000
+  9871	0.000	0.000	0.000	0.000	1.000	0.000	0.000
+  9901	0.000	0.000	0.000	0.000	0.999	0.000	0.001
+  9931	0.000	0.000	0.000	0.000	0.981	0.000	0.019

src/prokov/lxpack/tests/test.score.ref

@@ -0,0 +1,128 @@
+BASU_000010  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000020  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000030  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000040  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000050  0.970  0.000  0.000  0.000  0.000  0.000  0.030
+BASU_000060  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000070  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000130  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000140  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000150  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000160  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000170  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000180  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000200  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000210  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000220  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000230  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000240  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000250  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000260  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000270  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000280  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000290  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000350  0.524  0.000  0.000  0.000  0.000  0.000  0.476
+BASU_000360  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000370  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000380  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000390  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000400  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000410  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000420  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000430  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000440  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000450  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000460  0.998  0.000  0.000  0.000  0.000  0.000  0.002
+BASU_000470  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000480  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000490  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000500  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000510  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000520  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000530  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000540  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000550  0.994  0.000  0.000  0.000  0.000  0.000  0.006
+BASU_000560  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000570  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000580  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000590  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000600  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000610  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000620  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000630  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000640  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000650  0.995  0.000  0.000  0.000  0.000  0.000  0.005
+BASU_000660  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000670  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000680  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000690  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000700  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000710  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000720  0.976  0.000  0.000  0.000  0.000  0.000  0.024
+BASU_000730  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000740  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000770  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000780  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000790  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000800  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000810  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000820  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000830  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000840  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000850  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000860  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000870  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000880  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000890  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000900  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000910  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000920  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000930  0.999  0.000  0.000  0.000  0.000  0.000  0.001
+BASU_000940  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_000950  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001110  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001120  0.872  0.000  0.000  0.000  0.000  0.000  0.128
+BASU_001130  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001140  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001150  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001160  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001170  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001180  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001190  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001200  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001210  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001220  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001230  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001240  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001250  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001260  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001270  0.006  0.000  0.004  0.000  0.000  0.000  0.990
+BASU_001280  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001290  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001300  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001310  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001320  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001330  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001340  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001350  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001360  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001370  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001380  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001390  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001400  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001410  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001420  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001430  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001440  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001450  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001460  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001470  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001480  0.965  0.000  0.000  0.000  0.000  0.000  0.035
+BASU_001490  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001500  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001510  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001520  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001530  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001540  0.999  0.000  0.000  0.000  0.000  0.000  0.001
+BASU_001550  1.000  0.000  0.000  0.000  0.000  0.000  0.000
+BASU_001560  1.000  0.000  0.000  0.000  0.000  0.000  0.000