class Lexique

Construction

__init__

Optional keywords:

fic=f

builds from filename f, using read_nf;

fprop=f

builds from filename f of Lproportion, using read_Lprop;

str=s

builds from string s, using read_str;

alpha=a

uses the letters of string a, in use with option str (see input);

read_nf

builds from a filename and optionaly a string of letters (see input);

read_str

builds from a string and optionaly another string of letters (see input).

read_prop

builds from a Proportion, using loglex. For efficiency considerations, the proportions priors and posteriors are translated differently (see descriptors):

• priors are clustered in a tree from the last letters to the first ones, and each leaf of this tree will be the output of the corresponding posterior. Afterwards, these labels are output with backward-or (|{}) operator along the edges of the tree, and the posteriors are output in their specific format. The order in backward-or operator is not related with any order in the proportions. Priority is given to the most specific prior. The -100000 labels are for not-matching priors.
  
  Example: The output of the posteriors are replaced by the `'.
  
  
  
  
• posteriors are clustered in a tree from the first letters to the last ones, and each leaf of this tree is the logarithm of the corresponding proportion. Afterwards, the labels are output with the here-or (|()) and forward-or (|`') operators. -100000 labels are for not-matching posteriors.
  
  

read_Lprop

builds from a Lproportion, each Proportion being translated as in read_prop, and the transitions between descriptors are valued by the logarithms of the transitions proportions.

Handling

is_empty

returns True if there is no descriptor, False otherwise;

__len__

returns the number of descriptors;

ls_num

returns the list of the numbers of the descriptors;

met_au_net

removes repetitions in patterns of descriptors (like ACAC cleaned in AC) and repetitions of descriptors (like A A cleaned in A);

__iter__

iterates over the descriptors, using for d in lx;

__delitem__

removes the descriptor of a given number;

__setitem__

adds a descriptor given its number, or a descriptor pattern given a tuple. Given numbers must not have been previously used.

For example:

>>> import lexique
>>> l=lexique.Lexique(str="1:A  2,3:BC")
>>> print l
3,2:CB  1:A     

>>> l[2]
'2:B'
>>> l[4]='D'
>>> print l
4:D     3,2:CB  1:A     

>>> l[3,5]='EF'
Bad descriptor number  3  already used
>>> l[6,5]='EF'
>>> print l
5,6:FE  4:D     3,2:CB  1:A     

>>> del l[4]
>>> l[4]='F'
>>> print l
4:F     5,6:FE  3,2:CB  1:A     

>>> del l[2]
>>> print l
4:F     5,6:FE  3:C     1:A     

prediction

computes the best prediction on a data, without using between-descriptors transitions;

Optional keywords:

deb=d

sets the first position of the segment on which the prediction is computed (default: 0);

fin=f

sets the last position of the segment on which the prediction is computed (default: last position-1);

If deb>fin, it returns 0.

ls_evalue

returns the dictionnary of tuple of (the pattern of) numbers of descriptors, prediction of this (pattern of) descriptor on the data, for all descriptors, on a given data.

Optional keywords:

deb=d

sets the first position of the segment on which the predictions are computed (default: 0);

fin=f

sets the last position of the segment on which the predictions are computed (default: last position -1 );

If deb>fin, it returns 0.

windows

computes the list of the best predictions on the data in a sliding window of a given size and with steps of a given length;

Input-Output

• Output
  
  Specific format is:
  

  description numbers_of_descriptors_separated_by_commas:       outputs_of_the_descriptors_in_the_pattern_separated by spaces.   optional lines of transitions costs between the descriptors, in format: number_of_descriptor,number_of_descriptor     cost

  examples   1,2:+{A(-1)CG}T 3:C     1:A 2:C 3:G 4:T     1,2,3:A|`C(0.3)GT(0.2)A'{C(0.5)A(-1.5)} 5:+(CG) 10:`T(-0.23)!(0.1)'     1:A 2:T   1,1 -2.3 1,2 -4.1 2,2 7.2 2,1 0

  __str__

  outputs in specific format.

  
  
  
• Input
  
  Input is in the same format as the output, plus:
  • there is no need to give numbers to the descriptors. In that case, they will be automatically numbered;
  • character $ is a wildcard, and cannot be used as a standard letter. It is used in method read_str, and is set successively on all of the letters of the second string argument of this method. For example:
    • lit_str("$", "ACG") builds Lexique: A C G
    • lit_str("A$A", "TG") builds Lexique: ATA AGA
    • lit_str("`A$$'", "CGT") builds Lexique:
      `ACC' `ACG' `ACT' `AGC' `AGG' `AGT' `ATC' `ATG' `ATT'