The Necklace Illustrator Web Applet

(1)

Rochester Institute of Technology

RIT Scholar Works

Theses

Thesis/Dissertation Collections

2005

The Necklace Illustrator Web Applet

David W. Fraser

Follow this and additional works at:

http://scholarworks.rit.edu/theses

This Thesis is brought to you for free and open access by the Thesis/Dissertation Collections at RIT Scholar Works. It has been accepted for inclusion in Theses by an authorized administrator of RIT Scholar Works. For more information, please contactritscholarworks@rit.edu.

Recommended Citation

(2)

The Necklace Illustrator Web Applet

by

David W. Fraser

A Report Submitted

m

Partial Fu)fi]]ment of the

Requirements for the Degree of

Master of Science

m

Applied Mathematics

Approved by

Principal

Advisor:_..:...P=-au=I:....:W~ils::...;:o~n-'-

_ _ _ _ _ _ _ _ _ _ _ _ _

_

Dr.

Paul Wilson

Committee Member:

_-~~~~~---

David Hart

Prof. David

Hart

Committee Member:---=D=:..a=r'-'-re=n'-'--'-N=ac.:....:ra:::..lyc..:::a:...:...;n~

_ _ _ _ _ _ _ _ _ _ _ _

_

Dr. Darren Naravan

Committee Member: Hossein Shahmahamad

Dr. Hossein Shahmohamad

Department of Mathematics and Statistics

Rochester Institute of Technology

(3)

RIT DML

Electronic Thesis

&

Dissertation (ETD)

Thesis/Capstone Project

Author Permission Statement

Title of thesis/Capstone project:

i 1'Jl..

!Jet.

Jt,~L<--l:

lilA

sift;

to

r LJ

e

Jo

,A

ppl

e

t-I, David Fraser , hereby grant the nonexclusive license to the Rochester Institute of Technology Digital Media Library (RIT DML) to archive and provide electronic access to my thesis/Capstone project in perpetuity.

I hereby certify that, if appropriate, I have obtained and attached written permission statements from the owners of each third party copyrighted matter to be included in my thesis/Capstone project. I certify that the version I submitted is the same as that approved by my advisor and/or committee.

I hereby grant to the Rochester Institute of Technology and its agents the non-exclusive license to archive and make accessible my thesis/Capstone project in whole or in part in all forms of media. I understand that my work, in addition to its bibliographic record and abstract, will be available to the world-wide community of scholars and researchers through the RIT DML.

I retain all other ownership rights to the copyright of my thesis/Capstone project. I also retain the right to use in future works (such as articles or books) all or part of my thesis/Capstone project. The Rochester Institute of Technology does not require registration of copyright for thesis/Capstone projects

Signature of author: --;D=-.::::ac....:.v..:...id:::...:..F-=-r.=a..::.s.=e..:....r _ _ _ _ --:-_ _ _ _ _ _ _ _ _ _ _ _ _

Date:

'-113,

1

0 )" Degree: ..4..tII---<4 _ _ _ _ _ _ _ _ _ _ _

College: ~c.. €VlLi...

(4)

Table ofContents

SectionI: Background 1

Introductionto Necklaces 1

TheDihedral _Group 1

Burnside'sTheorem 2

The Cycle Index 3

The Pattern_Inventory 4

Section II: TheApplet 6

IntroductiontoJava 6

Applet Overview 7

Input 8

The Cycle Index 8

The Pattern_Inventory 8

NecklaceIllustrations 10

Section III: Problemsand Fixes 12

SectionIV: TheCode 16

CIDraw.java 17

Cyclelndexjava 19

CyclelndexList.java 36

CyclelndexObj.java 37

DrawObj.java 38

Necklace.java 47

NecklaceCompute.java 54

NecklaceObj.java 63

Patternlnventory.java 66

PatternlnventoryObj.java 84

(5)

SectionI: Background

IntroductiontoNecklaces

In terms ofCombinatorics and Graph _Theory, a necklace is a cycle with each vertex (or

"bead")given a certain color. Theproblemisto countthenumber of necklaceshavingnbeadsif

k colors are available. The number of distinct necklaces can be determined _{by building} the

pattern_inventory, apolynomial with variables_representingdifferentcolors, theexponents ofthe

variables _representing the number ofbeads of_{that color,} and the coefficients _representing the number ofdistinct necklaces with that coloring. For _example, a necklace made offive beads

using the colors black and white has the pattern _inventory

b5

+2b3w2+bw4+b4w+2b2w3 +W5.

Twonecklaces are consideredidentical ifthereexist symmetries suchthat thenecklaces look

the same after the symmetries are applied. For example, the figure below shows three necklaces, eachmade oftwo whitebeads and two _{gray beads.} Necklace 1 andNecklace 2 are distinctsincethereisno_symmetrythat canbeappliedto makethemlookthe same. Necklace 2

andNecklace _3, _however, are not considereddistinct since a clockwise rotation of90 applied toNecklace 2wouldhave itappearidenticaltoNecklace 3.

Necklace 1 Necklace 2 Necklace 3

The Dihedral_Group

Before discussion of necklace _counting can _begin, one must first understand the dihedral group. Thisis theset ofrigidmotions on an -gon. Itconsistsofrotationsandreflections. The

followingparagraphs explaindihedralgroups intermsof necklaceswith an evenor odd number

ofbeads.

(6)

opposite _beads, we can consider aline of reflection_running through these pairs. _Finally, there

are n/2 pairs of opposite edges and we can consider a line of reflection _running through these

pairs. In_total, we seethatthere are atotalof2nsymmetries onanecklace ofeven beads. The

followingfigureshowsthelinesofreflectionforafour-beadnecklace.

In the case ofan odd number ofbeads, the number of rotations is similar to that ineven

necklaces. The lines of_reflection, however are not the same. There are no pairs of opposite

beads or opposite edges. _Instead, a line of reflection is constructed from each bead to the

opposite edge. _Again, thisgives n rotations and n reflectionsfor a totalof2 symmetries. The

followingfigureshowsthelinesof reflectionforafive-beadnecklace.

Burnside's Theorem

Therearetwo versions ofBurnside's Theorem (alsoknownasNot Burnside's Theoremsince

theresultswereknownto_CauchyandFrobenius decades before Burnside's_proof)when applied

to thenecklaceproblem. _Theyare asfollows:

(1) N=-l-Z*7*

(2) N=-LZG*(*)

Inthese equations, N isthenumberofdistinct_coloringofa necklacewitha given number of

colors. _\G\ isthenumberofpermutation ofthenecklace. Thisisthe size ofthedihedral group,

(7)

x is _anyone coloring. _0(x) denotes the number of symmetries that leave the coloring x fixed.

Equation ₍₂₎ uses _G, _jt, and ft. G isthe _group of permutations or symmetries ofthe necklace

and ^is_anyone permutation of symmetry. _\j/(n)isthenumber of coloringsinTleftfixedbytt.

What Burnside's Theoremsays isthat thenumber ofdistinctnecklacesisequalto thenumber

ofcoloringsleft fixed_byall symmetriesdivided_by2n.

The CycleIndex

The first_step in_findingthepattern_inventoryforagiven numberof colors andbeadsistofind

the cycle index for a given number ofbeads. To do so, we must find the cycle structure

representation ofeachsymmetry. Wecandothisfortherotationsin adirect manner. Foreach

rotation,wetrace thepathofthebeadsthroughthe rotatioa Considerthe _following four-bead

necklace.

o

_Consider

all rotations to be in a clockwise direction. For a rotation of0 (we can also

considerthis a rotationof_360), eachbead remains fixed. _Thus, we have a cycle structure of

(a)(b)(c)(d). Fora rotation of_90,agoesto_b,b goes_{to c,}cgoesto_d,anddgoestoa. Thisis

acycle structure of(abed). Forrotations of180 and _270, we get _(ac)(bd) and (adeb). For

reflections about the lines through opposite edges, we get _(ab)(cd) and (ad)(bc). _Finally, for

reflectionsaboutthelinesfromato c andfrombto _d,we get_(a)(bd)(c)and(ac)(b)(d).

The next _step is to convert these cycles into a notation in terms ofx. Eachx will have a

subscriptand asuperscript.

Xjwill appearforeach ofthe/timesa cycle of_length/occursinthe

cycle structure for each symmetry. For _{the rotations,} we get _{x\, x\, x\,} and x\. For the

reflections, we get_x\, _{x\, x\x\,} and x\x\. _Groupingthe terms together gives_x\ + _2x\ + _3>x\ +

2x\Xj.

Cycle Index Term Cycle Structure

x\ (a)(b)(c)(d)

2x\ (abcd),{adcb)

3xf (ac)(bd),(ab)(cd),(ad)(bc)

(8)

Nowconsider a necklace withfive beads. _Again, there are fiveclockwise rotations, eacha

multiple of72. Forarotation of0(or_360),we get acycle structureof(a)(b)(c)(d)(e). Fora

rotationof_72, we haveacycle structure of(abode). In fact, for each rotation other than_0,

wehavethecycle structureof(abcde). Thereflections aboutthelines from verticesto opposite

edges givethecycle structures_(a)(be)(cd),_{(b)(ac)(de), (c)(bd)(ae), (d)(ce)(ab),}and(e)(ad)(bc).

Converting these cycle structures into cycle index _notation, we get _xf for 0 and_x\ for all

other rotations. Eachofthereflections gives xlx^. Thereforethecycleindex is_xf +_4x\ + 5x\xl.

CycleIndex Term Cycle Structure

x? (a)(b)(e)(d)(e)

4x\ (abcde),(acebd),(adbec),(aedcb)

Sx\4 (a)(be)(cd)Xb)(ac)(deUc)(bd)(ae),(d)(ce)(ab),(e)(ad)(bc)

We candrawsome generalizations about _computingthe cycle indexwithout_having to trace

the locations through all rotations and reflections. When_considering therotations ofnecklace

with n beads, index them as 1 through n. The cycle index term for the fth rotation will be

x/gcd(/jj)- The cycle indexterms forthe reflections will depend on whether n is even or odd.

Forodd_n,allthereflectiontermswill_{be x}x2} ~

. Whenn iseven, therewillbe termsofthe fornix^2

and |termsoftheformx?x^"2)/2.

ThePattern_Inventory

Once we have computed the cycle _index, we are _readyto determine thepattern _inventory.

Construct anexpression foreachterm inthe cycle indexasfollows: {cr +bc*

+... +

c^)e such

that a, b, ..., c are variables representing different colors, d is the subscript ofthe cycle index

term, and e is the superscript ofthe cycle index term. _Expanding this polynomial willalmost

result in the pattern _inventory for the chosen colors and number of _beads. _Each _distinct

(9)

betoolarge_byafactorof2n. _Simply_dividingthecoefficientsby2willgivethedesiredresult.

Suppose that we were to color a four-bead necklace with black and white beads. We start

withthecycleindex for four _beads,_x\ +2x\+ _3x\ +2x\x\. _Next,we insert(bl + _wV foreach xj. This gives us (b + w)4

+ 2(b4 + _w4) + ₃₍b2+ w2)2

+ 2(b + w)2(b2

+ w2). _Following

expansion and coefficientdivision_by _8,we are leftwithanexpression ofb4 + b3w + 2b2 vr +

Zw3 ₊

w4. _Reading_{the coefficients, this tells} usthat thereis onlyone distinct necklace with all black _beads, one with threeblack andone white _bead, two withtwo blackand two white, one

(10)

SectionII: The Applet

The Necklace

Illustrator

Red Beads 4'

m W:

Blue Beads 2 ?

!-:;:'|aflri;t#^

Green Beads fm*

Yellow Beads o ;?

Cycle Index: x7 + 6xJ +

7x\x|

Necklaces 1 through 9

oo

o

Pattern Inventory:r7₊r^1 ₊i^g1₊_3^+ 3rsb1g1 + SrSg2 + Afiti3 +9r4b2g1 + grVg2 +

4,4g3 + 4r3b4 +₁oWg1 +₁8r3b2g2 +₁Dr^g3+ 4r3g4+3^13^+9r2b4g1₊

1S^t^g2 +₁S^l^g3 +

9r2b1g4+3r2g5 +r1b6+ Sr^g1 + 9r1b4g2 + 10r1b3g3 + 9r1b2g4 +3r1b1g5 +r1g6+ b7+ b6g1 +

3ifi^* 4b4g3+_AtPgP+ 3b2g5 +b1ge₊g7

Introduction to Java

Thissectioncontainsterms that_maynotbeunderstood_bya readerthatdoesnotknowmuch

about the _{Java programming language.} This is a brief introduction that explains some ofthe

moreimportanttermsused.

Java is an object-oriented language. This means that a program consists of _interacting

objects,each with certaindataandfunctionspredefined. Thesedataandfunctiondefinitionsare

determined _by the class to which an object belongs. When a new object is created in the

program,it isaninstanceofaclass.

(11)

passed or returndataas wellasperform operations.

AnAppletisatypeofJavaprogram. Itrequires aJavaenvironment, suchas aJava-enabled

web_browser,to run.

Whenwe _saythat Class Aextends Class _B, it meansthat a newclass, ClassA, was created

that inheritsalltheproperties ofClassB inadditionto_anynew methods added.

Therewere somestandardJavaclassesthatwereusedin creatingthisApplet. One suchclass

istheVectorclass. This is essentiallyan_arraythatcontains objects. Thedifferencebetweenthe

Vectorandtheusual_{Java array}isthatthe_arraymustbepassed_itsmaximum sizeuponcreation

and aVectorisresizable.

Anotherclass _repeatedlyused wastheCanvasclass. TheCanvasis_typicallyusedfor_drawing

tothescreen.

Applet Overview

The Applet is designed to _display three different results based on the selection ofbeads

chosen_bytheuser. Thefirstresultis thecycleindexofthe totalnumber ofbeadschosen. The

second result is the pattern _inventory for the number and colors ofbeads chosen. _Finally, all

distinctnecklacesbasedontheselectedbeadsaredisplayedingroups of_upto ten.

Upon_loading, theAppletgivestheuserfour drop-downselectionboxes fromwhich_theycan

choosethe number ofbeads ofeach color. Thevalid colors are _red, _blue, _green, and yellow.

Thevalidchoicesforeachcolorrangefromzerotofive.

When the usertriggers _any ofthedrop-down boxesand selects anumber for_{that color, the}

Applet automaticallycomputes and displaysthenew cycleindex and patterninventory. The list

ofdistinctnecklaces are not_{automatically} _drawn, however. Theuser must first click abutton

labelled "Drawfirst 10". Iftherearetenorfewer_necklaces, _theyarealldrawnonthescreen. If

therearemore _{than ten necklaces,} the "Draw first 10"

buttonisre-labelled "Drawnext 10". A

newbuttonisalso createdlabelled "Newnecklace". This secondbutton is included incase the

user nolongerwishesto viewthecurrent necklace and make a new colorselection. Aftera new

selection of _colors, _clicking the "New necklace"

button will terminate _illustrating the first

necklace and willbegin _drawingthedistinct necklacesforthenewcolorselection. Whenall of

thenecklaces have been shown, the "Draw next 10" _button is once again labelled "Drawfirst

10"

andthe"Newnecklace"

(12)

Input

The Necklace Applet itself is visually divided into four separate panels. Thefirst isused for

input. It contains four JComboBox _objects, one for each color. A JComboBox is a "drop-down"

menufor selecting data. EachJComboBoxhasanActionListenerattachedto it so that when a new number is selected fromthat box, the routinesfor _computing cycle indexand pattern _inventory are _{automatically} run. The input panel contains the "Draw first 10"/"Draw next 10" button and the "New necklace"

button. These buttons also have ActionListeners

attachedtoruntheappropriate routines.

Thepanels forthe cycle _index, pattern_inventory, and necklaceillustrations contain objects thatextendtheCanvasclass_containingmodifiedpaintmethods.

IntheeventofanActionListener_beingtriggeredbycolor selectionor abuttonclick, thefirst

thingthat occursthat thevaluesinthefour JComboBoxesarestored as integervariablesforthe fourcolors. The Appletthendetermines whetherit was a colorselection or abuttonclick that

occurred

TheCycle Index

Whena newcolorselection ismade, a Cyclelndexobject iscreated forthe total number of

beads. This Cyclelndex object has the task of_creating a Vector that stores CyclelndexList

objects. The CyclelndexList isan objectthatcontainsaninteger coefficientas wellasaVector

containingeitherone ortwo _{CyclelndexObj} objects. These_{CyclelndexObj} objects representthe

'x'

in the cycle index and store the superscript and subscript. The Cyclelndex object has

hardcodedroutinesfortotalbeadvaluesonethrough twenty.

Oncethe Cyclelndex object is _{created, the}Vectorthat stores the appropriatecycle index is

passedto aCIDrawobject. The CIDrawobjectisa canvas onwhichthecycleindex is drawnto

be displayedto theuser.

ThePattern_Inventory

Next, a_{Patternlnventory}object iscreated andispassedthe_{Vector containing}thecycleindex

as well as the number of_red, _blue, _green, and yellow beads. This object first _determines _the

number ofbeadsused. Specificmethodsare calledforone ortwobeads. Foratotalbeadcount

(13)

the pattern _inventory are stored in _{PatternlnventoryObj} objects. These _simply store integer

coefficientsas well as exponents forthe variables_r, _b,_g, and y. All PatternlnventoryObjterms

are storedinaVectorwithinthe_{Patternlnventory}object.

Ifthereisone_bead,a_{PatternlnventoryObj}iscreatedthat setstheexponent oftheappropriate

variableto 1 andisaddedtotheVector.

Ifthere are two _beads, the _{Patternlnventory}determines if_theyareboththe same color. If

theyare, a_{PatternlnventoryObj}iscreatedthat setstheexponent oftheappropriate variableto 2

and is added to the Vector. When there are two beads of two different colors, a

PatternlnventoryObj is created that sets the exponents ofthe appropriate variables to 1 and is

addedto theVector.

When there are more than two beads, there are four different methods to determine the

patterninventory.

Inthe simplestcase where_onlyone coloris_used, a_{PatternlnventoryObj} object iscreated

that sets the exponent oftheappropriate variable to the number ofbeads and is added to the

Vector.

Whenthere are _{two colors,} each CyclelndexList object is read except for the last one,

whichcontains two _{CyclelndexObj} objects(or V values). For each of_these, the superscript is

read and used to compute the terms of the polynomial in the _following manner: Let

r=superscript ofthe cycle index term,y=exponent ofthe first color, fc=exponent ofthe second

color, and /w=subscript ofthe cycle indexterm, _jrunsfrom 0to iand kruns from to 0 such

that y + k=

i ineachterm. Abinomialcoefficient isproduced for eachpairof _jand kand all

exponents are multiplied_bym. Whenthis is done forallbutthe last_{CyclelndexList,} the terms

are all grouped together. Forthe last _{CyclelndexList,} a similar process occurs foreachofthe

two V terms and _they are multiplied together _by _taking all pairs of _terms, _adding their

exponents, and_multiplying their coefficients. Alllike termsare groupedtogetherforthe entire

pattern inventory. Finally, all coefficients are _divided _by 2n for the final pattern _inventory

expression. Each term is stored in a Vector as a _{PatternlnventoryObj} object that stores the

coefficient aswellastheexponentsforeach color variable.

Whenthere arethree orfour_{colors, the}procedures are similar. _First, a_{four-dimensional}

array is created _{using Vectors.} This is done _by _creating three Vectors that contain Vector

objects. The fourthVectorcontains _{PatternlnventoryObj}objects that store thecoefficients and exponents for each color variables. When _initially _created, the indices ofthe four Vectors

representthe exponentsstored inthePatternlnventoryObj. Thecoefficients are allinitializedto

(14)

similartothetwo-colorcase. Allexponentsforthevariables are foundsuchthat_theyadd_upto

the superscriptofthe _{CyclelndexObj,}a multinomial coefficient isgenerated, and the exponents

are multiplied _by the

CyclelndexObj

subscript. The four-dimensional array is then accessed

based onthe variable exponents andthe current coefficient isadded to the coefficient stored in

thearray. Forthelast _{CyclelndexList,} eachofthe'x' termsisexpandedina similarmanner. For

eachterm inthe second _'x1, theterms ofthe first 'x'

are multiplied _by_adding the exponentsand

multiplying the coefficients. The _array is thenaccessed and the current coefficient is addedto

the coefficient stored inthe array. Finally, all_{PatternlnventoryObj} objects stored inthe _array

are examined and ifthe coefficient is not _0, it is written to a Vector that can _quickly give all

termsofthepatterninventory.

Once the _{Patternlnventory} object is created, the Vectorthat stores the appropriate pattern

inventory is passed to a PIDraw object _along with the number ofbeads of each color. The

PIDraw object is a _{Canvas-extending} object on which the pattern _inventory is drawn to be

displayedto theuser. Whenthe exponents ofthecolors matchthecolor selection given_bythe

user, the termis displayed inabold font.

Necklace Illustrations

Whenthe userselectseitherofthe drawbuttons,theAppletcreates a newNecklaceCompute

object whichdoesthecalculations for_determining distinctnecklaces. Duetorestrictionsonthe

largercases, ismust first be determined ifthecolorselectiongiven issmallenoughto compute.

Withthecutoffdeterminedto begreaterthan 14beads_usingallfour_colors,a_flag isset. Ifthe

selectionis too _large,amessageis displayed_saying so. Otherwisetheprocess continues. _First,

the color selection is transformed into a _string representation. For example, 'rrbbbg' would

represent twored _beads,threeblue_beads, and onegreenbead. Apartiallistof permutations of

this_stringisthengenerated. _Thispartiallistcontains stringsthatrepresentalldistinctnecklaces.

Toreducethenumberof_{permutations,}_onlythosethat beginwiththe letterofthe smallest color

chosen are generated. Whenalloftheseare_generated, _theyare examinedto seeif_theyalso end

with the smallest color chosen. If_so, _they are _discounted since _they represent necklaces that

have undergone a rotation and are a duplicate of some necklace that does not end with the

smallest color chosen. Withthe list ofpermutations minimized inthis _manner, each_remaining

string ispassed to anew_NecklaceObjobjectthat storesthe _string, the_{string reversed,} and two integers called the forNum and backNum that represent all consecutive pairs ofletters in the

(15)

forward _string is traversed and consecutive letters are considered. Based on what these two

letters _are, the forNum is multiplied _by a certain prime number. Likewise, then backNum is

generated_by_traversing thebackward _string, _considering consecutive letters, and_multiplying_by

a certain prime number. This_way, weknowwhat letters are adjacentforward andback, which

helps speed _up _determining duplicate necklaces. These _NecklaceObj objects are stored in a

Vector.

Withthe_NecklaceObjVectorgenerated, theAppletcan nowstart_{eliminating duplicates.} To

speed _up _{the process,} _only _up to ten distinct necklaces are identified at a time. The

NecklaceCompute is passed the Vector of_NecklaceObj objects as well as the start and end

indices ofthe desired necklaces. For _example, it can be passed 0 to _9, 10 to _19, or 20 to 29.

Theprocedure is done_by_startingat thelower indexand_comparingtoeach prior_NecklaceObj,

all ofwhichareassumedtobe distinct. TheforNumsare_firstcompared andif_they_match, there

is the _possibility that _they are duplicate necklaces. The forward _string is then rotated _by

repeatedly moving the leading character to the end. Ifthe strings match at _any _{point, the}

process is terminated and the current _NecklaceObj is marked as a duplicate. Ifthere is no

match, the backNum of the current _NecklaceObj is compared to the forNum of the prior

NecklaceObj. If_theyare_{the same,}a similarrotation process occurstolook foramatch. Ifit is

determinedthat the current_NecklaceObj isa_duplicate, it is removed andthenext_NecklaceObj

goes through the same process. If it is determined that the current _NecklaceObj is not a

duplicate,it isgrouped withthepriordistinctnecklaces and thenext_NecklaceObjgoes through

the same process. This repeats until either the upper index is reached or all necklaces are

compared.

Itisthen time todrawthecurrentset of necklaces. A_DrawObjobjectiscreatedthatrenders

thecurrent setoftenorless necklaces. This isdone _by_passing the_DrawObj the_NecklaceObj

Vector and _selecting the forward strings for the current set of necklaces. When the first ten

necklaces are _drawn, a "New necklace"

button is created in case the user wishes to view

necklaces of anewcolor selection. Once the entire set ofdistinctnecklacesisdrawn,the "New

necklace"

(16)

Section III: Problemsandfixes

During the _writing ofthis _Applet, anumber of problems arose. The followingparagraphs documenttheseproblems anddescribe how_theywere eitherfixedorworked around.

The firstproblem encountered washowto generate alist ofpermutations ofa string. Thisin itselfwouldhave beennoproblemifallthecharacterswere_distinct, butthefactthat therecould

be repeated characters meant therewould be_many repeated permutations. Afterseveral hours

searching Java booksandthe_Internet, littleprogress had beenmade. The_keywasterminology. Whenthe searchwas changed from

'permutation'

to _'anagram', a solution was soonfound. An

anagram-generating algorithm was found in An Introduction to Object-Oriented_Programming

with Java _by C. Thomas Wu. This algorithm also assumed non-repeated character, but it was

easily adapted to take repeated characters into account. This can be found in the NecklaceComputeclassin_{the permutationGeneratorO}method.

Oncethislist of permutations wasobtained, itwastime to start_makingitmore efficient. The list could grow quite largeand contain _manyduplicate necklaces. The first taskwas to find a

wayto eliminate as _manystrings as possible without the risk of_losing _{any distinct} necklaces. This was done _by _{considering only} strings that start withthe letter _{corresponding}to the color

withthe smallest number ofbeads. _Anyother _string couldbe considered aduplicate ofone of these (either forward or _backward) after some rotation was applied. _Therefore, _any other

string'snecklace would be a duplicate of at leastone string'snecklace fromthe smaller set. A

second check was set _upto eliminate furtherduplicates fromthissmaller set. The last character

ofthe _string is checked and if it also is the letter _{corresponding} to the color withthe smallest

number of_beads, it is discounted. This is due to the factthat the necklace itrepresents would bearotationof some necklace whose_stringdidnotendinthesameletter.

The firstproblemthatwaspure Java programmingand notalgorithm-orientedwasthat when

the distinct necklaces were drawn on the screen and another window was opened over these

necklaces, theywoulddisappearwhen_returningtotheApplet. Thisproblemexisted forseveral

weeks and _any attempts to fix it failed. The vitalpiece ofinformation concernedthe Canvas

class that was usedin_drawingthesenecklaces. When a_{Canvas-extending}object iscovered on

the screen,itrecallsits_paint()methodupon_beingexposed again. When_{nothing is in}the_paintO

method, thedefaultisto clearthe screeninthat area. The_DrawObj classwaswritten_extending

(17)

Whentheuser selected a necklace composed ofjust one_color,nonecklaces would be drawn. Thiswas a result ofthe method used for_obtaining the necklace strings. When a _stringbegan and ended withthe same _character, it was discounted. With only one colorused, there is only

one _stringand all_characters, _includingthe firstand _last, arethe same. This stringwould never be considered and an _{empty Vector} would be created. Special code was inserted in the

permutation generator ofthe NecklaceCompute object to handle the case where there wasjust

onebeadandthecasewheretherewere multiplebeadsof_onlyone color.

Duringtesting,several combinationsofbeadswere showntohaveproblems withthenumber

ofnecklacesdisplay. Oneofthefirst to beproblematic was a3-3-2 combination whentheuser

selected_{two red, three} _blue, andthree green. It displayedadifferent number of necklacesthan when the user selected _{three red, three} _blue, and _{two green,} which gave the correct number.

The problem was traced back to the omission of an equal sign. When _determining whether

necklaces were_distinct, theNecklaceCompute would go_up, but not_including, the upper index

sent _bythe Applet. Thismeant that a few necklaces were not checked and were reported as

distinctwhen_theywereduplicates.

Aproblem wasfound whentheAppletwas run on some, butnotall, Macintoshcomputers.

Problems _loadingthe Appletwere found_{using both}the Safari andInternet Explorer browsers. Similar problems were later encountered when _attempting to load theApplet onto a Windows computer withInternet Explorer. In thecase ofthe Windows computer, _trip to www.sun.com resulted in _downloading an up-to-date version of the Java Runtime Environment. After

installation,theAppletloadedand performed properly.

Aproblem was foundwhen _trying to _displaynecklaces with alarge number ofbeads. The

case that first found this problem was five _{red, three} _blue, five _green, and four yellow. The

problem was tracked back to a _{Java memory} problem. Even when the permutation list is minimized as described above, there are problems with large cases. Although the program

discounts _many strings as _being _duplicates, the recursive nature ofthe permutation generator

meant that all permutations were _generated, ifnot saved. A new method was added to the permutation generator that would _onlybuild strings that started with the letter ofthe smallest color. Even withthis _implemented, there were stillproblems withthe largercases. The _only workaround was to impose a limit so that for these larger _{cases, the} work would not be done

that resulted in the _memory errors. After _testing, the _breaking point appeared to be whenthe user selected morethanfourteen beads_usingallfourcolors.

Displaying the cycle index and pattern _inventory requires the use of subscripts and

(18)

to use a _{StyledDocument} and add each piece individually. Each time the style of the text

changed, the StyledDocument style had to be changed. This worked for the cycle _index, but

problems wouldlaterarise withthepatterninventory.

The next problem that presented itselfwas the question ofhow to expand the pattern

inventorypolynomial based onthe cycle index and colors chosen. The initial attempt mirrored

the_{way in}whichonewould expandpolynomials_byhand. Thetermsinsidetheparenthesiswere determined _by the colors chosen and the cycle index subscript (for example, r4

+ o1

+ g4).

They were then multiplied _by itself_by_taking individual terms and _adding the exponents. This

was repeated_accordingto the superscript ofthecycleindex. Whenthisprocess wascompleted,

alltermswere addedto aVector. TheVectorwouldthenbe traversedand the termswouldbe

grouped_together, _{resulting in} a coefficient foreachterm. Whilethis workedforsmall _cases, it

was _highly inefficient and failed _completely due to _{memory issues} with even _moderately large

cases. Asearchwas conductedto findifotherJavaclasses couldhandle_takingthe expression

as a _string, _expanding the _polynomial, and _returning the expression as a _string that could be

displayed. Some were found,but_theyall provedto bequite complexand_learning to use them would be_fairly difficult in a short amount oftime. _Returning to _writing a new _{procedure, the}

result was the process described in the previous section that can be found in the

Patternlnventoryclass.

Oncethepattern_inventorycouldbecomputed andstored inaVectorof_{PatternlnventoryObj}

objects, a new problem arose _{concerning how} to _display them. When the number ofbeads

grows largeenough, the panel usedto _displaythe terms hadproblems sincethe termswere all displayed _{horizontally by} the StyledDocument. In _addition, cases that were small enough to displaybut still_fairlylargewere slowto display. The solution was torenderthemas a_drawing as donewiththenecklaces. Insteadof a _{StyledDocument,} a_{Canvas-extending} objectwas used that drew the terms on the screen in the panel The main problem was _keeping track ofthe locationwhere itemsshouldbedrawn, sincethe_changingstylesfromregulartext to superscript

textcauseddifferencesintextwidthmeasurements.

This approach to_writing thepattern_inventory_worked, but it was stilltoo slow. Eachtime

the screen was refreshed, it would have to write eachterm _{individually,} whichwas a problem

when there were _many terms. For each _term, the coefficient was drawn in addition to _any

variable with a non-zero exponent as well asthe exponent. To _{fix this,} amethod was included

that created a Bufferedlmage. The terms were then drawn onto this image. Now when the

screenisrefreshed,itsimplyredraws oneimageinsteadof alltheindividualterms.

(19)

green. The pattern _inventory says that there should be ten distinct necklaces with this color

selection. Inpractice,not_onlywere eight display,but_theywere labelled "Necklaces 1 1 through 18". _Reviewingthecodefor_determining distinctnecklaces foundconsecutive ifstatementsthat

had opposite conditions. Whilethe second condition was _initiallyfalse, _executing the code for

the first if statement caused it to be true. _Changing this to an if-else statement resolved the

problem.

The final fewproblemfixesdealtwiththenecklace_drawingofmiscellaneous cases. One such

case was whenthe numberofnecklaces was a multiple often. In some instances, there were

additional stringsto check for _duplicity, so the Applet did not knowthat alldistinct necklaces had _already been displayed. Ifthere were _only_ten, for instance, the final necklace illustration

wouldbe blankexceptforatitlethatread"Necklaces 11 to 10". Thiswasfixed_by_addingsome

code to theNecklaceand PIDrawclasses. Asthe PIDrawstepsthroughthe pattern_inventory

terms, itchecksto see ifthetermcorresponds to the color selection given_bytheuser. Ifso,it

is drawn inabold font. In_{addition, the} coefficientisnoted asthemaximumnumber ofdistinct

necklaces. The Necklaceclassusesthiscoefficient as a cutofffor_drawingnecklaces.

Iftheuser attemptedto drawnecklaces with no beads,the drawpanel wouldbe blank with

thetitle "Necklaces 1 to 0". Codewasinsertedinthe_DrawObjclassto instead_displaythe title

"Nothingselected".

The final problem encountered was one which was thought of _earlier, but dismissed as

unlikelyto occur. When_testingthepattern_inventoryfor_{twenty beads,}five of each_color, _many ofthe largest coefficients came _up as negativenumbers. In _Java,the intdatatype has a range

up to 2147483647. All ofthe coefficients were withinthis range. The problem wasthat this

number must first be divided_by40. Priorto this _division, thenumbers wereoutsidethe range. Whenthis_happens, the integer "wraps around"

andbecomes anegative number. Thenumbers

were changed from the int data type to the _long data _type, which has a range _up to

(20)

Section IV: The Code

The

following

pages contain the Java code for all classes used _by the Necklace Illustrator

(21)

/*

*

CIDraw.java *

ForusewiththeNecklaceIllustrator Applet

*

byDavidFraser

*

RochesterInstitute_of_Technology *

May2005 *

*/

package_Necklace;

import_{java.awt.Canvas;} import_{java.awt.Graphics;}

import_{java.awt.Font;}

import_{java.lang.Integer;}

importjava.util._Vector;

importNecklace._{CyclelndexList;}

importNecklace.CyclelndexObj; import_{java.awt.FontMetrics;}

public classCIDrawextendsCanvas_{

VectorciVector;

Graphicsg;

//createa newCIDrawthatispassedtheCycle Index Vector

publicCIDraw(Vector vec) _{ ciVector=

vec;

g=getGraphicsO;

}

//paintmethod usedtorendertoscreen

public void paint(Graphics _g){

Font boldFont=

new_{Font("boldFont",}_{java.awt.Font.BOLD, 12);}

g.setFont(boldFont);

g.drawString("CycleIndex: _{", 10,20);} intnewX=

10+tliis.getFontMetrics(bol(lFont).stringWidth("CycleIndex: _");

//ifthe Cycle Index Vector isnot_empty if(ciVector. sizeO!=0) {

FontregFont=

new_{Font("regFont",}_{java.awt.Font.PLATN,} _12); FontsmallFont=

new_{Font("smallFont",}_{java.awt.Font.PLATN,} _10);

g.setFont(regFont);

(22)

CyclelndexListciList=

(CyclelndexList)ciVector.elementAt(i); VectortempVector=

ciList.getCyclelndexEntryO;

Integerconvlnt=

new_Integer(0);

//ifthecoefficientisnotI, drawtoscreen

if(ciList.getCoeffO!=l){

StringtempStr=

convInt.toString(ciList.getCoeff()); g.drawString(tempStr,newX,20);

newX=

newX+diis.getFontMetrics(regFont).stringWidth(tempStr); }

//foreach "x"interm:

for (int_{j=0; j<tempVector.sizeO;}_j++){

CyclelndexObjciObj=(CyclelndexObj)tempVector.elementAt(j); g.setFont(regFont);

//draw "x"

g.drawStringC'x", newX,20);

newX=

l+newX+this.getFontMetrics(regFont).stringWidth("x");

g.setFont(smallFont);

//drawsuperscript andsubscript StringtempSup=

convInt.toString(ciObj.getSupO);

StringtempSub=

convInt.toString(ciObj.getSubO);

g.drawString(tempSup, newX, 16);

g.drawString(tempSub,newX,24);

newX=newX+_{java.lang.Mam.max(this.getFontMetrics(smalIFont)}

.stringWidm(tempSup),this.getFontMetrics(boldFont) .stringWidth(tempSub));

}

//ifnotthelastterm if (i!=ciVector.

size()-₁ ){ g._{setFont(regFont);} //draw "

+ " g.drawString("

+ _",_newX,_20);

newX=newX+this.getFontMetrics(regFont).stringWidth("

+_"); }

} }

g.dispose();

(23)

/*

*_{Cyclelndex.java}

*

Foruse withtheNecklaceIllustrator Applet *

byDavidFraser *

Rochester Institute_of_Technology *

May2005 *

*/

package_Necklace;

import java.util._Vector;

public classCyclelndex _{

privateVectorcyclelndexVector;

//createa newCyclelndex

public_CyclelndexO _{

}

//createa newCyclelndexthatispassedthenumber_{of beads}

publicCyclelndex(int_{beads) {}

cyclelndexVector=

new_Vector();

//checkthenumber_of_beads, call appropriate method

switch_{(beads) {}

case 1: _oneBeadO;

break;

case2: _twoBeadO;

break;

case3: _threeBeadO; break;

case4: fourBead(); break;

case5: fiveBeadO; break;

case6: _sixBeadO;

break;

case7: sevenBeadO;

break;

case 8: eightBeadO;

break;

case9: nineBeadO;

break;

(24)

break;

case 11: _{elevenBead();}

break;

case 12: _{twelveBead();} break;

case 13: _{thirteenBeadO;}

break;

case 14: _{fourteenBeadO;} break;

case 15: _{fifteenBeadO;}

break;

case 16: sixteenBead(); break;

case 17: _{seventeenBeadO;} break;

case 18: _{eighteenBeadO;} break;

case 19: nineteenBeadO; break;

case20: _{twentyBead();}

break;

}

private void_oneBead(){

//createx(sub(l), sup(l))

CyclelndexListtempList=

new_{CyclelndexListO;}

CyclelndexObjtempObj=

new_{CycleIndexObj(l,l);}

tempList.addCI(tempObj); tempList.setCoeff(l);

cycleIndexVector.add(tempList);

}

private void_twoBead(){

//createx(sub(l), sup(2)) CyclelndexListtempListOne=

CyclelndexObj tempObjOne=

new_{CycleIndexObj(2,l);}

tempListOne.addCI(tempObjOne);

tempListOne._{setCoeff( 1}₎_;

cyclelndexVector.add(tempListOne);

//createx(sub(2), sup(l)) CyclelndexListtempListTwo=

CyclelndexObjtempObjTwo=

new_{CycleIndexObj(l,2);}

(25)

tempListTwo.setCoeff(1_);

cyclelndexVector.add(tempListTwo); }

private void_threeBead(){ //createx(sub(l), sup(3))

CyclelndexListtempListOne=

tempListOne.setCoeff(1);

//create_2*x(sub(3), _sup(l))

CyclelndexListtempListTwo=

newCycleIndexObj(l,3);

tempListTwo.addCI(tempObjTwo);

tempListTwo.setCoeff(2);

cycleIndexVector.add(tempListTwo);

//create3*x(sub(l), sup(l))*x(sub(2), sup(l))

CyclelndexListtempListThree=

CyclelndexObjtempObjThreeA=

CyclelndexObj tempObjThreeB=

tempListThree.addCI(tempObjThreeA); ternpListThree.addCI(tempObjThreeB);

ternpListThree.setCoeff(3);

cycleIndexVector.add(tempListThree);

}

privatevoid_fourBeadO{ //createx(sub(l), sup(4))

CyclelndexObjtempObjOne=

tempListOne.setCoefftT);

//create2*x(sub(4), sup(l))

CyclelndexObj tempObjTwo=

new_{CycleIndexObj(l,4);} tempListTwo.addCI(tempObjTwo);

(26)

//create3*x(sub(2), sup(2)) CyclelndexListtempListThree=

newCyclelndexListO;

CyclelndexObjtempObjThree=

new_{CycleIndexObj(2,2);}

tempListThree.addCI(tempObjThree); tempListThree.setCoeff(3);

cyclelndexVector.add(tempListThree);

//create_2*x(sub(l), sup(2))*x(sub(2), sup(l)) CyclelndexListtempListFour=

CyclelndexObj tempObjFourA=

newCycleIndexObj(2,l);

CyclelndexObjtempObjFourB=

newCycleIndexObj(l,2);

tempListFour.addCI(tempObjFourA); tempListFour.addCI(tempObjFourB); tempListFour.setCoeff(2);

cycleIndexVector.add(tempListFour);

}

privatevoid_fiveBeadOl

//createx(sub(l), sup(5))

tempListOne.setCoefl(1_);

tempListTwo.addCI(tempObjTwo); tempListTwo.setCoeff(4);

//create5*x(sub(l), sup(l))*x(sub(2), sup(2)) CyclelndexListtempListThree=

CyclelndexObjtempObjThreeB=

new_{CyclelndexObj(2,2);}

tempListThree.addCI(tempObjThreeA);

tempListThree.addCI(tempObjThreeB); tempListThree.setCoeff(5);

cycleIndexVector.add(tempListThree); }

privatevoid_sixBeadO{

(27)

}

new_{CycleIndexObj(6,l);} tempListOne.addCI(tempObjOne);

tempListOne.setCoeff(1_);

cycleIndexVector.add(tempListOne);

//create_2*x(sub(3), _sub(2)) CyclelndexListtempListThree=

new_{CyclelndexListO;} CyclelndexObjtempObjThree=

new_{CycleIndexObj(2,3);} tempListThree.addCI(tempObjThree);

tempListThree.setCoeff(2);

//create4*x(sub(2), sup(3)) CyclelndexListtempListFour=

new_{CyclelndexListO;} CyclelndexObjtempObjFour=

new_{CycleIndexObj(3,2);} tempListFour.addCI(tempObjFour);

tempListFour.setCoeff(4);

cyclelndexVector.add(tempListFour);

//create3_*x(sub(l), _sup(2))_*x(sub(2), _sup(2)) CyclelndexListtempListFive=

CyclelndexObjtempObjFiveA=

new_{CycleIndexObj(2,l);} CyclelndexObjtempObjFiveB=

new_{CycleIndexObj(2,2);} tempListFive.addCI(tempObjFiveA);

tempListFive.addCI(tempObjFiveB);

tempListFive.setCoeff(3);

cycleIndexVector.add(tempListFive);

privatevoid_sevenBeadO{ //createx(sub(l), sup(7)) CyclelndexListtempListOne=

tempListOne._{setCoeff( 1}₎_;

(28)

//create 7*x(sub(l), sup(l))*x(sub(2), sup(3)) CyclelndexListtempListThree=

CyclelndexObj tempObjThreeA=

newCycleIndexObj(l,l);

tempListThree.addCI(tempObjThreeA); tempListThree.addCI(tempObjThreeB); tempListThree._setCoeff(7);

}

private void_eightBeadO{

tempListOne.addCI(tempObjOne); tempListOne.setCoeff(l);

//create4*x(sub(8),sup(l))

CyclelndexObj tempObjTwo=

//create2*x(sub(4), sup(2))

//create_5*x(sub(2), _sup(4))

CyclelndexListtempListFour=

CyclelndexObjtempObjFour=

tempLisfFour.addCI(tempObjFour);

(29)

//create_4*x(sub(l), sup(2))*x(sub(2), sup(3))

CyclelndexListtempListFive=

new_{CycleIndexObj(2,l);} CyclelndexObjtempObjFiveB=

tempListFive.addCI(tempObjFiveA);

tempListFive.addCI(tempObjFiveB); tempListFive.setCoefl(4);

}

private void_nineBeadO{

newCycleIndexObj(9,l);

//create6*x(sub(9), sup(l)) CyclelndexListtempListTwo=

tempListThree.addCI(tempObjThree);

//create9*x(sub(l), sup(l))*x(sub(2), sup(4)) CyclelndexListtempListFour=

CyclelndexObjtempObjFourA=

CyclelndexObjtempObjFourB=

tempListFour.addCI(tempObjFourA);

tempListFour.addCI(tempObjFourB);

cyclelndexVector._{add(tempListFour)}; }

private void_tenBeadO{

(30)

}

newCyclelndexListO; CyclelndexObjtempObjOne=

tempListOne.addCI(tempObjOne); tempListOne.setCoeff(l_);

//create _4*x(sub(10),_sup(l)) CyclelndexListtempListTwo=

CyclelndexObjtempObjTwo =

tempListTwo.addCI(tempObjTwo); tempListTwo.setCoefl(4);

tempListThree.addCI(tempObjThree);

CyclelndexListtempLisfFour=

tempListFour.addCI(tempObjFour);

//create5*x(sub(l), sup(2))*x(sub(2), sup(4)) CyclelndexListtempListFive=

CyclelndexObjtempObjFiveB=

tempListFive. setCoeff(5);

private void_elevenBeadO{

//createx(sub(l), sup(ll)) CyclelndexListtempListOne=

newCycleIndexObj(l_1,1);

tempListOne._{setCoeff( 1}_);

(31)

//create_{IO*x(sub(lI),} _sup(l)) CyclelndexListtempListTwo=

new_{CyclelndexListO;} CyclelndexObjtempObjTwo=

newCycleIndexObj(l,l_1); tempListTwo.addCI(tempObjTwo);

tempListTwo.setCoefl(l_0);

//create _ll*x(sub(l), sup(l))*x(sub(2), sup(5))

new_{CyclelndexListO;} CyclelndexObjtempObjThreeA=

tempListThree.addCI(ternpObjThreeA);

tempListThree.addCI(tempObjThreeB); tempListThree.setCoeff(l_1);

}

private void_twelveBeadO{

new_{CyclelndexListO;} CyclelndexObjtempObjOne=

tempLisfTwo.setCoeff(4);

tempListThree.addCI(ternpObjThree); tempListThree.setCoeff(2);

(32)

newCyclelndexListO; CyclelndexObjtempObjFive=

tempListFive.addCI(tempObjFive); tempListFive.setCoeff(2);

//create _7*x(sub(2), _sup(6)) CyclelndexListtempListSix=

CyclelndexObjtempObjSix=

newCycleIndexObj(6,2);

tempListSix.addCI(tempObjSix);

tempListSix.setCoeff(7);

cycleIndexVector.add(tempListSix);

//create 6*x(sub(l), sup(2))*x(sub(2), sup(5))

CyclelndexListtempListSeven=

newCyclelndexListO;

CyclelndexObjtempObjSevenA=

CyclelndexObjtempObjSevenB=

tempListSeven.addCI(tempObjSevenA);

tempListSeven.addCI(tempObjSevenB);

tempListSeven.setCoeff(6);

cycleIndexVector.add(tempListSeven);

}

private void_{thirteenBeadO{} //createx(sub(l), _sup(13))

//create 12*x(sub(13), sup(l)) CyclelndexListtempListTwo=

new_{CyclelndexListO;} CyclelndexObjtempObjTwo=

tempListTwo.setCoeff(l_2);

//create 13*x(sub(l), sup(l))*x(sub(2), sup(6)) CyclelndexListtempListThree=

(33)

tempListThree.addCI(tempObjThreeB);

tempListThree._setCoeff(1_3);

cycleIndexVector.add(tempListThree); }

private void_{fourteenBead(){} //createx(sub(l), sup(14))

tempListOne._{setCoeff( 1}₎;

//create _6*x(sub(14), _sup(l))

CyclelndexListtempListTwo =

newCyclelndexListO;

ternpListFour.addCI(tempObjFour);

//create 7*x(sub(l), sup(2))*x(sub(2),sup(6))

}

(34)

}

new_{CyclelndexListO;} CyclelndexObjtempObjOne=

newCyclelndexListO; CyclelndexObjtempObjTwo=

newCycleIndexObj(l,15); tempListTwo.addCI(tempObjTwo);

new_{CycleIndexObj(3,5);} tempListThree.addCI(tempObjThree);

tempListFour._setCoefi(2);

//create _15*x(sub(l), sup(l))*x(sub(2), sup(7)) CyclelndexListtempListFive=

new_{CycleIndexObj(7,2);} tempListFive.addCI(tempObjFiveA);

privatevoid_{sixteenBeadO{}

new_{CycleIndexObj(16,l);} tempListOne.addCI(tempObjOne);

tempListOne.setCoeff(l);

(35)

//create_8*x(sub(16), _sup(I))

newCyclelndexListO;

newCycleIndexObj(4,4); tempListFour.addCI(tempObjFour);

CyclelndexObjtempObjFive=

tempListFive.addCI(tempObjFive); tempListFive.setCoeff(9);

//create8*x(sub(l), sup(2))*x(sub(2), sup(7)) CyclelndexListtempListSix=

CyclelndexObjtempObjSixA=

CyclelndexObjtempObjSixB=

tempListSix.addCI(tempObjSixA);

tempListSix.addCI(tempObjSixB);

tempListSix.setCoeff(8);

cycleIndexVector.add(tempListSix); }

private void_{seventeenBeadO{}

//createx(sub(l), sup(l₇₎₎

(36)

cyclelndexVector_{.add(tempListOne)}_;

//create I6*x(sub(I7), sup(l)) CyclelndexListtempListTwo=

newCyclelndexListO;

//create 17*x(sub(l), sup(l))*x(sub(2), sup(8))

newCyclelndexListO;

tempListThree.addCI(ternpObjThreeA); tempListThree.addCI(tempObjThreeB); tempListThree.setCoeff(1_7);

}

privatevoid_{eighteenBeadO{}

tempListOne.addCI(tempObjOne); tempListOne.setCoeff(l);

//create _6*x(sub(9), _sup(2))

(37)

//create_2*x(sub(3), _sup(6)) CyclelndexListtempListFive=

new_{CycleIndexObj(6,3);} tempListFive.addCI(tempObjFive);

cyclelndexVector.add(tempListFive);

//create10*x(sub(2), sup(9)) CyclelndexListtempListSix=

newCyclelndexListO;

CyclelndexObjtempObjSix=

tempListSix.addCI(tempObjSix); tempListSix.setCoeff(10);

cyclelndexVector.add(tempListSix);

//create_9*x(sub(l), sup(2))*x(sub(2), sup(8))

CyclelndexListtempListSeven=

tempListSeven.addCI(tempObjSevenA); tempListSeven. addCI(tempObjSevenB); tempListSeven.setCoeff(9);

cyclelndexVector.add(tempListSeven);

}

privatevoid_{nineteenBeadO{}

//create19*x(sub(l), sup(l))*x(sub(2), sup(9))

(38)

}

tempListThree.addCI(tempObjThreeA); ternpListThree.addCI(tempObjThreeB);

tempListThree.setCoeff(1_9);

private void_twentyBeadO{

//createx(sub(I),sup(20))

tempListOne._{setCoeff( 1}_);

//create_8*x(sub(20), _sup(l)) CyclelndexListtempListTwo=

//create _4*x(sub(10), _sup(2))

tempListTnree.addCI(tempObjThree);

cyclelndexVector._{add(tempListThree)}_;

tempListFour.addCI(tempObjFour);

tempListFour._setCoeff(4);

//create2*x(sub(4), sup(5)) CyclelndexListtempListFive=

tempListFive.addCI(tempObjFive);

//createll*x(sub(2), sup(10)) CyclelndexListtempListSix=

(39)

CyclelndexObj tempObjSix=

newCycleIndexObj(10,2);

tempListSix.addCI(tempObjSix);

tempListSbc.setCoeff(l_1);

cycleIndexVector.add(tempListSix);

//create _10*x(sub(l), sup(2))*x(sub(2), sup(9)) CyclelndexListtempListSeven=

tempListSeveiLaddCI(tempObjSevenA);

tempListSeven.addCI(tempObjSevenB);

tempListSeven._{setCoeff( 1}₀₎_;

cycleIndexVector.add(tempListSeven);

}

publicVector getCIVectorO{

//returntheCycleIndex Vector

(40)

/*

*

CyclelndexList.java *

ForusewiththeNecklaceIllustrator Applet *

byDavid Fraser *_Rochester

Institute_of_Technology *

May2005 *

*/

package_Necklace;

import java.util.Vector;

public classCyclelndexList _{

private_{Vector cyclelndexEntry}_;

privateint_coeff;

//createa newCyclelndexList

public_{CyclelndexListO {}

//createa new VectortostoreCycle Index "x"terms

cyclelndexEntry=

new_VectorO;

}

<