Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

3 Lists, Sets and Strings
3.1 Functions for lists
3.1-1 DifferencesList
3.1-2 QuotientsList
3.1-3 SearchCycle
3.1-4 RandomCombination
3.2 Distinct and Common Representatives
3.2-1 DistinctRepresentatives
3.3 Functions for strings
3.3-1 BlankFreeString

### 3 Lists, Sets and Strings

#### 3.1 Functions for lists

##### 3.1-1 DifferencesList

`‣ DifferencesList`( L ) | ( function )

This function has been transferred from package ResClasses.

It takes a list \(L\) of length \(n\) and outputs the list of length \(n-1\) containing all the differences \(L[i]-L[i-1]\).

    gap> List( [1..12], n->n^3 );
    [ 1, 8, 27, 64, 125, 216, 343, 512, 729, 1000, 1331, 1728 ]
    gap> DifferencesList( last );
    [ 7, 19, 37, 61, 91, 127, 169, 217, 271, 331, 397 ]
    gap> DifferencesList( last );
    [ 12, 18, 24, 30, 36, 42, 48, 54, 60, 66 ]
    gap> DifferencesList( last );
    [ 6, 6, 6, 6, 6, 6, 6, 6, 6 ]

##### 3.1-2 QuotientsList

`‣ QuotientsList`( L ) | ( function )

`‣ FloatQuotientsList`( L ) | ( function )

These functions have been transferred from package ResClasses.

They take a list \(L\) of length \(n\) and output the quotients \(L[i]/L[i-1]\) of consecutive entries in \(L\). An error is returned if an entry is zero.

    gap> List( [0..10], n -> Factorial(n) );
    [ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800 ]
    gap> QuotientsList( last );
    [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
    gap> L := [ 1, 3, 5, -1, -3, -5 ];;
    gap> QuotientsList( L );
    [ 3, 5/3, -1/5, 3, 5/3 ]
    gap> FloatQuotientsList( L );
    [ 3., 1.66667, -0.2, 3., 1.66667 ]
    gap> QuotientsList( [ 2, 1, 0, -1, -2 ] );
    [ 1/2, 0, fail, 2 ]
    gap> FloatQuotientsList( [1..10] );
    [ 2., 1.5, 1.33333, 1.25, 1.2, 1.16667, 1.14286, 1.125, 1.11111 ]
    gap> Product( last );
    10.

##### 3.1-3 SearchCycle

`‣ SearchCycle`( L ) | ( operation )

This function has been transferred from package RCWA.

`SearchCycle` is a tool to find likely cycles in lists. What, precisely, a cycle is, is deliberately fuzzy here, and may possibly even change. The idea is that the beginning of the list may be anything, following that the same pattern needs to be repeated several times in order to be recognized as a cycle.

    gap> L := [1..20];;  L[1]:=13;;
    gap> for i in [1..19] do
    >        if IsOddInt(L[i]) then L[i+1]:=3*L[i]+1; else L[i+1]:=L[i]/2; fi;
    >    od;
    gap> L;
    [ 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4, 2, 1, 4 ]
    gap> SearchCycle( L );
    [ 1, 4, 2 ]
    gap> n := 1;;  L := [n];;
    gap> for i in [1..100] do  n:=(n^2+1) mod 1093;  Add(L,n);  od;
    gap> L;
    [ 1, 2, 5, 26, 677, 363, 610, 481, 739, 715, 795, 272, 754, 157, 604, 848,
      1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271,
      211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521,
      378, 795, 272, 754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272,
      754, 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604,
      848, 1004, 271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004,
      271, 211, 802, 521, 378, 795, 272, 754, 157, 604, 848, 1004 ]
    gap> C := SearchCycle( L );
    [ 157, 604, 848, 1004, 271, 211, 802, 521, 378, 795, 272, 754 ]
    gap> P := Positions( L, 157 );
    [ 14, 26, 38, 50, 62, 74, 86, 98 ]
    gap> Length( C );  DifferencesList( P );
    12
    [ 12, 12, 12, 12, 12, 12, 12 ]

##### 3.1-4 RandomCombination

`‣ RandomCombination`( S, k ) | ( operation )

This function has been transferred from package ResClasses.

It returns a random unordered \(k\)-tuple of distinct elements of a set \(S\).

    gap> ## "6 aus 49" is a common lottery in Germany
    gap> RandomCombination( [1..49], 6 );
    [ 2, 16, 24, 26, 37, 47 ]

#### 3.2 Distinct and Common Representatives

##### 3.2-1 DistinctRepresentatives

`‣ DistinctRepresentatives`( list ) | ( operation )

`‣ CommonRepresentatives`( list ) | ( operation )

`‣ CommonTransversal`( grp, subgrp ) | ( operation )

`‣ IsCommonTransversal`( grp, subgrp, list ) | ( operation )

These operations have been transferred from package XMod.

They deal with lists of subsets of \([1 \ldots n]\) and construct systems of distinct and common representatives using simple, non-recursive, combinatorial algorithms.

When \(L\) is a set of \(n\) subsets of \([1 \ldots n]\) and the Hall condition is satisfied (the union of any \(k\) subsets has at least \(k\) elements), a set of `DistinctRepresentatives` exists.

When \(J,K\) are both lists of \(n\) sets, the operation `CommonRepresentatives` returns two lists: the set of representatives, and a permutation of the subsets of the second list.

The operation `CommonTransversal` may be used to provide a common transversal for the sets of left and right cosets of a subgroup \(H\) of a group \(G\), although a greedy algorithm is usually quicker.

    gap> J := [ [1,2,3], [3,4], [3,4], [1,2,4] ];;
    gap> DistinctRepresentatives( J );
    [ 1, 3, 4, 2 ]
    gap> K := [ [3,4], [1,2], [2,3], [2,3,4] ];;
    gap> CommonRepresentatives( J, K );
    [ [ 3, 3, 3, 1 ], [ 1, 3, 4, 2 ] ]
    gap> d16 := DihedralGroup( IsPermGroup, 16 );
    Group([ (1,2,3,4,5,6,7,8), (2,8)(3,7)(4,6) ])
    gap> SetName( d16, "d16" );
    gap> c4 := Subgroup( d16, [ d16.1^2 ] );
    Group([ (1,3,5,7)(2,4,6,8) ])
    gap> SetName( c4, "c4" );
    gap> RightCosets( d16, c4 );
    [ RightCoset(c4,()), RightCoset(c4,(2,8)(3,7)(4,6)), RightCoset(c4,(1,8,7,6,5,
       4,3,2)), RightCoset(c4,(1,8)(2,7)(3,6)(4,5)) ]
    gap> trans := CommonTransversal( d16, c4 );
    [ (), (2,8)(3,7)(4,6), (1,2,3,4,5,6,7,8), (1,2)(3,8)(4,7)(5,6) ]
    gap> IsCommonTransversal( d16, c4, trans );
    true

#### 3.3 Functions for strings

##### 3.3-1 BlankFreeString

`‣ BlankFreeString`( obj ) | ( function )

This function has been transferred from package ResClasses.

The result of `BlankFreeString( obj );` is a composite of the functions `String( obj )` and `RemoveCharacters( obj, " " );`.

    gap> gens := GeneratorsOfGroup( DihedralGroup(12) );
    [ f1, f2, f3 ]
    gap> String( gens );
    "[ f1, f2, f3 ]"
    gap> BlankFreeString( gens );
    "[f1,f2,f3]"

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind

generated by GAPDoc2HTML