~/Downloads/fricas-master/src$ grepfind . "resolve_level"
./interp/i-resolv.boot:507: $resolve_level > 15 => nil
./interp/i-resolv.boot:508: $resolve_level := $resolve_level + 1
./interp/i-resolv.boot:510: $resolve_level := $resolve_level - 1
./interp/i-syscmd.boot:2174: $resolve_level : local := 15
./interp/i-toplev.boot:285: $resolve_level : local := 0
./interp/trace.boot:593: $resolve_level : local := 0
no clues about boot:
resolveTM(t,m) ==
-- resolves a type with a mode which may be partially specified
startTimingProcess 'resolve
$Subst : local := NIL
$Coerce : local := 'T
m := SUBSTQ("**",$EmptyMode,m)
-- arbitrary limit
$resolve_level > 15 => nil
$resolve_level := $resolve_level + 1
tt := resolveTM1(t,m)
$resolve_level := $resolve_level - 1
result := tt and isValidType tt and tt
stopTimingProcess 'resolve
result
in interp/i-resolv.boot
It seems that $resolve_level is not declared, other as in the other two
files. Is this the problem, how to fix it?
The error occured at my implementation of database tables:
)co dbtable
)read pilzeClustering6.input
....
DBT'' := DatabaseTable(VAR, OBJ, ND, ID, CD)
(32) DatabaseTable(String,Integer,Float,Integer,String)
Type: Type
Time: 0 sec
PILZE'':=databaseTable(lvn, tL)$DBT''
>> System error:
The variable |$resolve_level| is unbound.
Am 26.06.18 um 14:59 schrieb Waldek Hebisch:
> Prof. Dr. Johannes Grabmeier wrote:
>> any idea what that means (used to work before):
>>
>>
>> Â Â >> System error:
>> Â Â The variable |$resolve_level| is unbound.
> What are you doing? If this is during tracing the problem
> should be solved in svn.
>
> Concerning the question: '$resolve_level' is a newly added
> variable and the message means that we forgot to put
> declaration in some places where it is needed.
>
--
Mit freundlichen Grüßen
Johannes Grabmeier
Fraktionsvorsitzender
FREIE WÄHLER, Stadtrat Deggendorf
Prof. Dr. Johannes Grabmeier
Köckstraße 1, D-94469 Deggendorf
Tel. +49-(0)-991-2979584, Tel. +49-(0)-151-681-70756
Fax: +49-(0)-322-241-92688
--
You received this message because you are subscribed to the Google Groups
"FriCAS - computer algebra system" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at https://groups.google.com/group/fricas-devel.
For more options, visit https://groups.google.com/d/optout.
--Copyright (c) 2009, 2016, 2017 Johannes Grabmeier
--All rights reserved.
--
--Redistribution and use in source and binary forms, with or without
--modification, are permitted provided that the following conditions are
--met:
--
-- - Redistributions of source code must retain the above copyright
-- notice, this list of conditions and the following disclaimer.
--
-- - Redistributions in binary form must reproduce the above copyright
-- notice, this list of conditions and the following disclaimer in
-- the documentation and/or other materials provided with the
-- distribution.
--
--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
)abbrev package TBLUTIL TableUtilities
++ Author: Johannes Grabmeier
++ Date Created: 16.06.09
++ Date Last Updated:
++ 17.01.2017: deleteVariable!
++ 14.12.2016:
++ Version:
++ Basic Functions:
++ Related Constructors:
++ Also See:
++ AMS Classifications:
++ Keywords:
++ References:
++ Description:
TableUtilities(S: SetCategory, T: SetCategory) : public == private where
NNI ==> NonNegativeInteger
--T ==> NonNegativeInteger -- make this more general:
CancellationAbelianMonoid
OF ==> OutputForm
public ==> with
innerTable: (Table(S,Table(S,T)), S) -> Table(S,T)
if (T has OrderedCancellationAbelianMonoid) or (T has Field) then
subtractTable: (Table(S,T), Table(S, T) ) -> Table(S, T)
++ subtractTable(t1, t2) returns the table with the difference of
++ all corresponding entries, it is assumed, that t1 and t2 have
++ the same set of keys!
if T has AbelianMonoid then
sumValues: Table(S,T) -> T
++ sumValues(t) the sum of entries in the table.
addTable: (Table(S,T), Table(S, T) ) -> Table(S, T)
++ addTable(t1, t2) returns the table with the sum of all
corresponding
++ entries, it is assumed, that t1 and t2 have the same set of keys!
private ==> add
--imports
import OutputForm
--exports
innerTable(t: Table(S, Table(S, T)), k: S): Table(S,T) ==
-- new inter table:
iT : Table(S, T) := table()
for l in keys t repeat iT.l := (t.l).k
iT
if T has AbelianMonoid then
sumValues(t: Table(S,T)): T ==
sm : T := 0
for v in entries t repeat sm := sm+v
sm
addTable(t1: Table(S,T), t2: Table(S,T) ): Table(S,T) ==
-- it is assumed, that t1 and t2 have the same set of keys!
for k in keys t1 repeat t1.k := t1.k + t2.k
t1
if T has OrderedCancellationAbelianMonoid or T has Field then
subtractTable(t1: Table(S,T), t2: Table(S,T) ): Table(S,T) ==
-- it is assumed, that t1 and t2 have the same set of keys!
-- and that subtraction works, i.e. 6-8 is not allowed
for k in keys t1 repeat
diff := subtractIfCan(t1.k, t2.k)
diff case "failed" => error "subtractTable: can not subtract"
t1.k := diff :: T
t1
)abbrev category DBTC DatabaseTableCategory
++ Author: Johannes Grabmeier
++ Date Created: 28.05.2009, 30.07.2009
++ Date Last Updated: 13.12.2016
++ Version:
++ Basic Functions:
++ Related Constructors: HashTable
++ Also See:
++ AMS Classifications:
++ VARwords:
++ References:
++ Description: a database table with 3 different types of entries:
FloatingPoint System ("f"),
++ IntegerNumberSystem "i" or SetCategory "c". The keys for the variables are
in SetCategory.
++ The value type indicators are "f", "i", "c".
DatabaseTableCategory(VAR: SetCategory, OBJ: SetCategory, ND:
FloatingPointSystem,
ID: IntegerNumberSystem, CD: SetCategory): Category ==
CategoryDefinition where
--ENTRY ==> Any
ENTRY ==> Union(ND, ID, CD, "null")
NNI ==> NonNegativeInteger
--ENTRY ==> Union(num: ND, dnm: ID, cat; CD, nul; "null")
CategoryDefinition ==> with
-------------------------------------------------------------------------
-- format of table
-------------------------------------------------------------------------
databaseTable: () -> %
++ databaseTable() creates a database table with no entries.
databaseTable: (List VAR, List String) -> %
++ databaseTable(lvn, lvt) creates a database table with no data, but
internally
++ provides empty tables for each of the variables in lvn of type in
lvt at
++ corresponding position.
loadVariable!: (%, VAR, String, Integer, List ENTRY) -> %
++ loadVariable!(dbT, v, tp, dist, le) adds the variable v of type tp.
Note: the
++ final argument must have as many elements as there are objects in the
++ database order!
addVariable!: (%, VAR, String, Integer) -> %
++ addVariable!(dbT, v, tp, dist) adds the variable v of type tp. Note:
all entries are set
++ to null.
deleteVariable!: (%, VAR) -> %
++ deleteVariable!(dbT, v) deletes variable v.
--------------------------------------------------------------------------
-- table information storage
--------------------------------------------------------------------------
setVariableTables!: (%, List Table(OBJ, ENTRY)) -> %
++ setVariableTables!(dbtbl, lVT) sets lVT as the variable tables of
++ dbtbl all other table parameters are assumed to be still correct!
setVariables!: (%, List VAR) -> %
++ setVariableTables!(dbtbl, lVar) sets lVar as the new variable list of
++ dbtbl, all other table parameters are assumed to be still correct!
setObjects!: (%, List OBJ) -> %
++ setVariableTables!(dbtbl, lObj) sets lOBj as the new variable list of
++ dbtbl, all other table parameters are assumed to be still correct!
setTypes!: (%, List String) -> %
++ setVariableTables!(dbtbl, lType) sets lType as the new type list of
++ dbtbl, all other table parameters are assumed to be still correct!
setDistances!: (%, List Integer) -> %
++ setVariableDistances!(dbtbl, lDist) sets lDIst as the new distance
list of
++ dbtbl, all other table parameters are assumed to be still correct!
--------------------------------------------------------------------------
-- information on the table, extract data:
--------------------------------------------------------------------------
variables: % -> List VAR
++ variables(dbtb) returns the list of variable names.
variable?: (%, VAR) -> Boolean
++ variable?(dbtb, vn) answers if vn is a valid variable in dbtb.
numberOfVariables: % -> NNI
++ numberOfVariables(dbtb: %) gives the number of variables.
variableNumbertable: % -> Table(VAR, Integer)
++ variableNumbertable(dbtb) provides a table with keys being the
variable names
++ and entries being an internal number, to have easy access to lists
of types etc.
variableTable: (%, VAR) -> Table(OBJ, ENTRY)
++ variableTable(dbtb, v) returns the internal table for the variable
v.
variableColumn: (%, VAR) -> Vector ENTRY
++ variableVolumn(dbtb, v) returns the internal vector of values for
the variable v
++ in the given order of the objects.
objects: % -> List OBJ
++ objects(dbtb) returns the list of objects names.
object?: (%, OBJ) -> Boolean
++ object?(dbtb, oj) answers if oj is a valid object in dbtb.
numberOfObjects: % -> NNI
++ numberOfObjects(dbtb: %) gives the number of objects.
objectRow: (%, OBJ) -> Vector ENTRY -- should go away, instead: simply
object
++ objectRow(dbtb, obj) returns the internal vector of values for the
object obj
++ in the given order of the variables.
object: (%, OBJ) -> Vector ENTRY
++ object(dbtb, obj) returns the internal vector of values for the
object obj
++ in the given order of the variables.
types: % -> List String
++ types(dbtb) returns the list of types.
type: (%, VAR) -> String
++ type(dbtb, v) returns the type of variable v, error if v is no
variable.
distances: % -> List Integer
++ distances(dbtb) returns the list of distances.
distance: (%, VAR) -> Integer
++ distance(dbtb, v) returns the distance of variable v for similarity
measures,
++ error if v is no variable.
variableTables: % -> List Table(OBJ, ENTRY)
++ variableTables(dbdbtbl: %) lists all tables, for each variable one.
-------------------------------------------------------------------------
-- implemented at categorial level:
-------------------------------------------------------------------------
keys: % -> List VAR
++ keys(dbtb) returns the list of variable names.
key?: (%, VAR) -> Boolean
++ key?(dbtb, vn) answers if vn is a valid variable in dbtb.
elt: (%, VAR) -> Vector ENTRY
++ elelt(dbtb, v) returns the internal vector of values for the
variable v
++ in the given order of the objects.
elt: (%, OBJ) -> Vector ENTRY
++ elt(dbtb, obj) returns the internal vector of values for the object
obj
++ in the given order of the variables.
elt: (%, VAR, OBJ) -> ENTRY
++ elt(dbtb, var, obj) returns the value of the variable var for the
object obj
variableToFunction: (%, OBJ) -> (VAR -> ENTRY)
++ variableToFunction(dbtbl, obj) creates a function, which can be
evaluated
++ for every variable var to return var(obj).
objectToFunction: (%, VAR) -> (OBJ -> ENTRY)
++ objectToFunction(dbtbl, var) creates a function, which can be
evaluated
++ for every object obj to return var(obj).
array: % -> TwoDimensionalArray ENTRY
++ array(dbtbl) returns the relational table as a two dimensional array.
histogramTable: (%, VAR) -> Table(ENTRY, Integer)
++ histogramTable(dbtbl, var) returns the frequency table for all
occuring values
++ of variable var, in particular useful, if type = "i".
categorialVariables: % -> List VAR
++ categorialVariables(dbtable) returns the list of all categorial
variables
++ i.e. those of type "s".
numericVariables: % -> List VAR
++ numericVariable(dbtable) returns the list of all numeric variables
++ i.e. those of type "n".
discreteNumericVariables: % -> List VAR
++ discreteNumericVariable(dbtable) returns the list of all discrete
numeric variables
++ i.e. those of type "i".
add
keys(dbtbl: %): List VAR == variables dbtbl
key?(dbtbl: %, var: VAR): Boolean == variable?(dbtbl, var)
elt(dbtbl: %, obj: OBJ): Vector ENTRY ==
not object?(dbtbl, obj) => error "elt: not a valid object name!"
objectRow(dbtbl, obj)
elt(dbtbl: %, var: VAR): Vector ENTRY ==
not variable?(dbtbl, var) => error "elt: not a valid variable name!"
variableColumn(dbtbl, var)
elt(dbtbl: %, var: VAR, obj: OBJ): ENTRY ==
not variable?(dbtbl, var) => error "elt: not a valid variable name!"
not object?(dbtbl, obj) => error "elt: not a valid object name!"
columnNumber: Integer := variableNumbertable(dbtbl).var
(variableTables(dbtbl).columnNumber).obj
variableToFunction(dbtbl: %, obj: OBJ): (VAR -> ENTRY) ==
var +-> elt(dbtbl, var, obj)
objectToFunction(dbtbl: %, var: VAR): (OBJ -> ENTRY) ==
obj +-> elt(dbtbl, var, obj)
array(dbtbl: %): TwoDimensionalArray ENTRY ==
arr : TwoDimensionalArray ENTRY := new(numberOfObjects dbtbl,
numberOfVariables dbtbl, autoCoerce("null"))
for j in 1..numberOfVariables dbtbl for var in variables dbtbl repeat
setColumn!(arr, j, oneDimensionalArray entries variableColumn(dbtbl,
var))
arr
histogramTable(dbtbl: %, var: VAR): Table(ENTRY, Integer) ==
not variable?(dbtbl, var) => error "histogramTable not a valid variable
name!"
ct : Table(ENTRY, Integer) := table()
vT : Table(OBJ, ENTRY) := variableTable(dbtbl, var)
e : ENTRY
for obj in objects dbtbl repeat
e := vT.obj
if key?(e, ct)
then setelt!(ct, e, ct.e+1)
else setelt!(ct, e, 1)
ct
--------------------------------------------------------------------------
-- information on the table, extract data:
--------------------------------------------------------------------------
selectVariablesByType(dbtbl: %, tp: String): List VAR ==
lV : List VAR := []
for t in types dbtbl for v in variables dbtbl repeat
if t = tp then lV := concat(lV, v)
lV
categorialVariables(dbtbl: %): List VAR ==
selectVariablesByType(dbtbl, "s")
numericVariables(dbtbl: %): List VAR ==
selectVariablesByType(dbtbl, "f")
discreteNumericVariables(dbtbl: %): List VAR ==
selectVariablesByType(dbtbl, "i")
)abbrev domain DBTBL DatabaseTable
-- with union
++ Author: Johannes Grabmeier
++ Date Created: 28.09.2009, 31.07.2009 JG in Dayton
++ Date Last Updated: 18.12.2016 JG in Deggendorf
++ Version:
++ Basic Functions:
++ Related Constructors: HashTable
++ Also See:
++ AMS Classifications:
++ VARwords:
++ References:
++ Description:
++ A database table is represented by
++ 1. a list of strings - the variable names,
++ 2. a list of equal length of strings to describe the format of the
variables
++ we have the types: "f" (float), "b" (binary), "i" (integer), "s"
(string),
++ 3. a list of equal length of integers to descripe the variable specific
distance
++ for similarity measures
++ 4. a hashtable which stores the number of the variable, the keys are the
variable names,
++ 5. a list of equal length of hash tables, where the keys are from the
key-domain
++ of the database table, and entry of type Any. The order of the tables
correspond
++ to the order of the variables.
++ The domain of database tables needs three domains as parameters, namely
++ ND for numerical data, a FloatingPointSystem
++ ID for integral (discrete numeric) data, an IntegerNumberSystem
++ CD for categorial data, a SetCategory
++ and a domain for the keys:
++ VAR: SetCategory.
DatabaseTable(VAR: SetCategory, OBJ: SetCategory, ND: FloatingPointSystem,
ID: IntegerNumberSystem, CD: SetCategory): public == private where
NNI ==> NonNegativeInteger
ENTRY ==> Union(ND, ID, CD, "null")
OF ==> OutputForm
public ==> DatabaseTableCategory(VAR, OBJ, ND, ID, CD) with
internalRepresentation: % ->
Record(varList: List VAR, typeList: List String, distanceList: List
Integer,
varNumberTable: Table(VAR, Integer), objList: List OBJ,
varTableList: List Table(OBJ, ENTRY) )
loadTableFromFixedRecordFile: (%, FileName, List NNI, List String) -> %
++ loadTableFromFixedRecordFile(dbtb, fn, lc, lt) -> %
loadTableFromCSVFile: (%, FileName, Character, List String) -> %
++ loadTableFromFixedRecordFile(dbtb, fn, c, lt) -> %
loadFixedRecordFile: (FileName, List NNI) -> List List String
++ loadFixedRecordFile(fn, lc) reads a file, which is assumed to have
fixed record
++ format, according to the column numbers of lc, each line is split to
get a
++ list of strings, als lines, i.e. list of stings, form the result, a
list of
++ list of string.
loadCSVFile: (FileName, Character) -> List List String
++ loadCSVFile(fn, c) reads a file, which is assumed to have csv format.
++ Using the character c as separator, each line is split to get a
++ list of strings, als lines, i.e. list of stings, form the result, a
list of
++ list of string.
addCategorialVariable!: (String, %) -> %
addCategorialTable: (List String, TwoDimensionalArray ENTRY) -> %
createCategorialTable: (List String, List VAR, TwoDimensionalArray ENTRY)
-> %
addNumericalVariable!: (String, %) -> %
addDiscreteNumericalVariable!: (String, %) -> %
private ==> add
-- representation
-- a table of tables does not seem to work
-- design:
++ v are the names of the variables,
++ c returns the column number for a variable,
++ d is a list of Tables with VARs and ENTRYs, each one for each variable
++ in the same order
++ t is
---------------------------------------------------------------------------
-- representation
---------------------------------------------------------------------------
Rep := Record(varList: List VAR, typeList: List String, distanceList: List
Integer,
varNumberTable: Table(VAR, Integer), objList: List OBJ,
varTableList: List Table(OBJ, ENTRY) )
rep(dbtbl : %) : Rep == dbtbl @ Rep
per(rp : Rep) : % == rp @ %
---------------------------------------------------------------------------
-- import
---------------------------------------------------------------------------
import OutputForm, StringUtilities
import AnyFunctions1(Null), AnyFunctions1(ND), AnyFunctions1(ID)
import AnyFunctions1(CD), AnyFunctions1(String)
---------------------------------------------------------------------------
-- local variables
---------------------------------------------------------------------------
nullEntry: ENTRY := autoCoerce("null")
---------------------------------------------------------------------------
-- local functions
---------------------------------------------------------------------------
updateVarTableList!(dbtbl: %, nv: Integer): Void ==
vNT : Table(VAR, Integer) := rep(dbtbl).varNumberTable
for k in keys vNT repeat
if vNT.k :: Integer > nv then vNT.k := vNT.k - 1
void()
---------------------------------------------------------------------------
-- function to create and extend a table
-- format functions
---------------------------------------------------------------------------
databaseTable(): % == per [empty()$List(VAR), empty()$List(String),
empty()$List(Integer),
table()$Table(VAR, Integer), empty()$List(OBJ),
empty()$List(Table(OBJ, ENTRY)) ]
databaseTable(lvn : List VAR, lvt: List String): % ==
dL : List Integer := new(#lvn, 0)
vNT : Table(VAR, Integer) := table()
for vn in lvn for j in 1..#lvn repeat setelt!(vNT, vn, j)
oL : List OBJ := []
vTL : List Table(OBJ, ENTRY) := [table() for k in 1..#lvn]
per [lvn, lvt, dL, vNT, oL, vTL]
ENTRY ==> Any
ND ==> Float
NND ==> Union(Null, ND)
CD ==> String
NCD ==> Union(Null, CD)
VAR ==> String
OBJ ==> Integer
DX ==> DecimalExpansion
ID ==> Integer
)if false
)set mess time on
outputFixed 1
fileDirectory : String := "."
filename'' : String := concat(fileDirectory,"/pilzeClustering6.csv")
dataFile'' : TextFile := open( filename'', "input")
)endif
lvn : List String := [ _
"Nummer","Namen","Futterform","Stielfarbe", _
"Ring", "HutMitSchuppen"_
]
aev : List String := [
"Futterform","Stielfarbe", _
"Ring", "HutMitSchuppen" _
]
-- Datentypen für die Tabelle: i = Integer, s = String
tL : List String :=
[ "i", "s", "s", "s", "s", "s"]
dL : List Integer :=
[ 0,0,0,0, 0,0]
DBT'' := DatabaseTable(VAR, OBJ, ND, ID, CD)
PILZE'':=databaseTable(lvn, tL)$DBT''
)fin
setDistances!(PILZE'', dL)$DBT''
lls'':=loadCSVFile(filename'', char ",")$DBT'';
PILZE'':=loadTableFromCSVFile(PILZE'', filename'', char ",", tL)$DBT'';
variables PILZE''
types PILZE''
distances PILZE''
categorialVariables PILZE''
discreteNumericVariables PILZE''
[histogramTable(PILZE'', v) for v in variables PILZE'']
array PILZE''
-- Aehnlichkeiten
CLAP := ClusterAnalysisPackage(VAR, OBJ, ND, ID, CD, PILZE'', DECIMAL)
n := numberOfObjects PILZE''
similarity(1,1,aev)$CLAP
sim := matrix [[similarity(i,j,aev)$CLAP for j in 1..n]for i in 1..n]
simFutterform := matrix [[similarity(i,j,["Futterform"])$CLAP for j in 1..n]for
i in 1..n]
simStielfarbe := matrix [[similarity(i,j,["Stielfarbe"])$CLAP for j in 1..n]for
i in 1..n]
simRing := matrix [[similarity(i,j,["Ring"])$CLAP for j in 1..n]for i in 1..n]
simHutMitSchuppen := matrix [[similarity(i,j,["HutMitSchuppen"])$CLAP for j in
1..n]for i in 1..n]
Cl0 := [1,2,3]
Cl1 := [4,5,6]
homogenity(Cl0, aev)$CLAP
homogenity(Cl1, aev)$CLAP
separability(Cl0, Cl1, aev)$CLAP
condorcetCriterium([Cl0, Cl1], aev)$CLAP :: FRAC INT
condorcetCriterium([[1], [2,3], Cl1], aev)$CLAP :: FRAC INT
condorcetCriterium([[2,3], [1,4,5,6]], aev)$CLAP :: FRAC INT
)fin
-- verschiedene Clustereinteilung:
objects := [i for i in 1..n]
lC0 := [objects]
condorcetCriterium(lC0, aev)$CLAP
lC1 := [[i] for i in 1..n]
condorcetCriterium(lC1, aev)$CLAP
--
lC2 := [[1,2,3],[4,5,6],[7,8,9,10]]
condorcetCriterium(lC2, aev)$CLAP
--
lC3 := [[1,2,6],[3,4,5,7],[8,9,10]]
condorcetCriterium(lC3, aev)$CLAP
lC4 := initialCondorcetClustering(objects, aev)$CLAc
condorcetCriterium(iC4, a2, aev)$CLAP
[[objectRow(PILZE'', i) for i in cl] for cl in lC4]
lC5 := improveCondorcetClustering(lC4, aev)$CLAP
condorcetCriterium(lC5, aev)$CLAP
[[objectRow(PILZE'', i) for i in cl] for cl in lC5]
lC6 := improveCondorcetClustering(lC5, aev)$CLAP
condorcetCriterium(lC6, aev)$CLAP
[[objectRow(PILZE'', i) for i in cl] for cl in lC6]
lC7 := improveCondorcetClustering(lC6, aev)$CLAP
condorcetCriterium(lC7, aev)$CLAP
[[objectRow(PILZE'', i) for i in cl] for cl in lC7]
