In CRISP, a class (in the set-theoretical sense) is usually represented by an algorithm which decides membership in that class. Wherever this makes sense, sets (see Set) may also be used as classes.

`IsClass(`

`) C`

returns true if `C` is a class object. The category of class objects is a
subcategory of the category `IsListOrCollection`

.

`Class(`

`) O`

`Class(`

`) O`

returns a class `C`. In the first form, `rec` must be a record having a
component `\in`

and an optional component `name`

. The values of these
components, if present, are bound to the attributes `MemberFunction`

and
`Name`

(see Name) of the class created. The value bound to `\in`

must be a function
`func` which returns `true`

if a GAP object belongs to `C`, and `false`

otherwise; cf. MemberFunction below. The second form is equivalent to ```
Class(rec(\in
:=
```

`func``))`

. It is the user's responsibility to ensure that `func` returns the same
result for different GAP objects representing the same mathematical object (or
element, in the GAP sense; see Objects and Elements in the GAP
reference manual).

gap> FermatPrimes := Class(p -> IsPrime(p) and p = 2^LogInt(p, 2) + 1); Class(in:=function( p ) ... end)

`View(`

`)`

If the class does not have a name, this produces a brief description of the
information defining `class` which has been supplied by the user. If the
class has a name, only its name will be printed.

gap> View(FermatPrimes); Class(in:=function( p ) ... end)

`Print(`

`)`

`Print`

behaves very similarly to `View`

, except that the defining
information is being printed in a more explicit way if possible.

gap> Print(FermatPrimes); Class(rec( in = function( p ) return IsPrime( p ) and p = 2 ^ LogInt( p, 2 ) + 1; end))

`Display(`

`)`

For classes, `Display`

works exactly as `Print`

.

` in `

returns true or false, depending upon whether `obj` belongs to `class` or
not. If `obj` can store attributes, the outcome of the membership test is
stored in an attribute `ComputedIsMembers`

of `obj`.

` = `

Since it is not possible to compare classes given by membership algorithms, two classes are equal in GAP if and only if they are the same GAP object (see IsIdenticalObj in the GAP reference manual).

` < `

The operation `<`

for classes has no mathematical meaning; it only exists
so that one can form sorted lists of classes.

`IsEmpty(`

`) P`

This property may be set to `true`

or `false`

if the class `C` is empty
resp. not empty.

`MemberFunction(`

`) A`

This attribute, if bound, stores a function with one argument, `obj`,
which decides if `obj` belongs to `C` or not, and returns `true`

and `false`

accordingly.
If present, this function is called by the default method for `\in`

.
`MemberFunction`

is part of the definition of `C` and should not be called
directly by the user.

`Complement(`

`) O`

returns the unary complement of the class `C`, that is, the class consisting
of all objects not in `C`. `C` may also be a set.

gap> cmpl := Complement([1,2]); Complement([ 1, 2 ]) gap> Complement(cmpl); [ 1, 2 ]

`Intersection(`

`) F`

`Intersection(`

`, `

`, ...) F`

returns the intersection of the groups in `list`, resp. of the classes
`C1`, `C2`, .... If one of the classes is a list with fewer than
`INTERSECTION_LIMIT`

elements, then the result will be
a sublist of that list. By default, `INTERSECTION_LIMIT`

is 1000.

gap> Intersection(Class(IsPrimeInt), [1..10]); [ 2, 3, 5, 7 ] gap> Intersection(Class(IsPrimeInt), Class(n -> n = 2^LogInt(n+1, 2) - 1)); Intersection([ Class(in:=function( N ) ... end), Class(in:=function( n ) ... end) ])

`Union(`

`, `

`) F`

returns the union of `C` and `D`.

gap> Union(Class(n -> n mod 2 = 0), Class(n -> n mod 3 = 0)); Union([ Class(in:=function( n ) ... end), Class(in:=function( n ) ... end) ])

`Difference(`

`, `

`) O`

returns the difference of `C` and `D`. If `C` is a list, then the
result will be a sublist of `C`.

gap> Difference(Class(IsPrimePowerInt), Class(IsPrimeInt)); Intersection([ Class(in:=function( n ) ... end), Complement(Class(in:=function( N ) ... end)) ]) gap> Difference([1..10], Class(IsPrimeInt)); [ 1, 4, 6, 8, 9, 10 ]

[Up] [Previous] [Next] [Index]

CRISP manual

March 2016