parti_simp.Parti_simp = class Parti_simp
    Simple partitioning
 
  Methods defined here:
__delitem__(self, i)
(x.__delitem__(i) <==> del x[i])
__delslice__(self, i, j)
(x.__delslice__(i,j) <==> del x[i:j])
__getitem__(self, i)
(x.__getitem__(i) <==> x[i])
__getslice__(self, i, j)
Return a Parti_simp made of the selected Partitions.
(x.__getslice__(i,j) <==> x[i:j]).
__init__(self, **kw)
Keyword argument:
fic --  build from filename f.
__len__(self)
(x.__len__() <==> len(x))
__str__(self)
(x.__str__()<==> str(x))
abr(self)
Return the string of the simple partitioning without the
descriptors.
append(self, p)
Append Partition p to the end of self. Data length of p must
be the same as the one of self.
build_random(self, lg, np)
Build a random (uniform distribution) np-partitioning on
data-length lg.
draw_nf(self, nf, **kw)
Draw with postscript langage in file of name nf.
        
Keyword arguments:
seg -- draw only the segments which descriptors have their number in
       the list seg;
num -- if equals 1, numbers of the descriptors are written;
func -- the height of each arc is proportional to lambda-function
        func(s) computed on each Segment s.
filter(self, func)
Return a Parti_simp made of the Partition for which function
func returns True.
group(self, lst)
Return a Parti_simp where the Partition are the result of method
group of Partition class applied on the Partition of self.
insert(self, i, p)
Insert Partition p before index i. Data length of p must
be the same as the one of self.
len_don(self)
Return data-length.
ls_val(self)
Return the list of the successive values.
mpp(self, d, l, i)
Compute a maximal predictive i-partitioning on data d
with Lexique l.
prediction(self, d, l)
Return the list of predictions on data d and Lexique l on
the partitions.
pts_comm(self, ps)
Return the number of different predictions with Parti_simp
ps, Partition after Partition.
Return -1 if data-lengths are different.
Predictors' numbers are only taken into account.
read_nf(self, nf)
Build from filename nf.
sort(self)
The partitions are sorted following their number of segment.