KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > JSci > maths > groups > CyclicGroup


1 package JSci.maths.groups;
2
3 /**
4 * The CyclicGroup class represents the <i>n</i>th cyclic group.
5 * Elements are represented by the integers mod <i>n</i>.
6 * @jsci.planetmath CyclicGroup
7 * @version 1.4
8 * @author Mark Hale
9 */
10 public final class CyclicGroup extends FiniteGroup implements AbelianGroup {
11         /**
12         * The zero element.
13         */
14         private final Member ZERO;
15         /**
16         * Constructs a cyclic group.
17         * @param n the order of the group
18         */
19         public CyclicGroup(int n) {
20                 super(n);
21                 ZERO = new Member(0);
22         }
23         /**
24         * Returns true if this group is isomorphic to another.
25         */
26         public boolean equals(Object JavaDoc o) {
27                 return (o instanceof CyclicGroup) && (((CyclicGroup)o).order == order);
28         }
29     public int hashCode() {
30         return order;
31     }
32         public String JavaDoc toString() {
33                 return "Z_"+order;
34         }
35         /**
36         * Returns an element from the group.
37         * @param i the integer representing the element
38         */
39         public Member getElement(int i) {
40                 return new Member(i);
41         }
42         /**
43         * Returns the elements of this group.
44         */
45         public Group.Member[] getElements() {
46                 Group.Member elements[] = new Group.Member[order];
47                 for(int i=0; i<order; i++)
48                         elements[i] = getElement(i);
49                 return elements;
50         }
51         /**
52         * Returns the identity element.
53         */
54         public AbelianGroup.Member zero() {
55                 return ZERO;
56         }
57         /**
58         * Returns true if the member is the identity element of this group.
59         * @param g a group member
60         */
61         public boolean isZero(AbelianGroup.Member g) {
62                 return g.equals(ZERO);
63         }
64         /**
65         * Returns true if one member is the negative (inverse) of the other.
66         * @param a a group member
67         * @param b a group member
68         */
69         public boolean isNegative(AbelianGroup.Member a, AbelianGroup.Member b) {
70                 return (a instanceof Member) && (b instanceof Member) && a.add(b).equals(ZERO);
71         }
72         /**
73         * Returns the identity element.
74         */
75         public Monoid.Member identity() {
76                 return ZERO;
77         }
78         /**
79         * Returns true if the member is the identity element of this group.
80         * @param g a group member
81         */
82         public boolean isIdentity(Monoid.Member g) {
83                 return g.equals(ZERO);
84         }
85         /**
86         * Returns true if one member is the inverse of the other.
87         * @param a a group member
88         * @param b a group member
89         */
90         public boolean isInverse(Group.Member a, Group.Member b) {
91                 return (a instanceof Member) && (b instanceof Member) && a.compose(b).equals(ZERO);
92         }
93         class Member implements AbelianGroup.Member, Group.Member {
94                 /** 0 <= i < order */
95                 private final int i;
96                 public Member(int x) {
97                         i = (x<0) ? x%order+order : x%order;
98                 }
99                 /**
100                 * Returns true if this member is equal to another.
101                 */
102                 public boolean equals(Object JavaDoc o) {
103                         return (o instanceof Member) && (i == ((Member)o).i);
104                 }
105         public int hashCode() {
106             return i;
107         }
108         public Object JavaDoc getSet() {
109             return CyclicGroup.this;
110         }
111                 /**
112                 * The group composition law.
113                 * @param g a group member
114                 */
115                 public AbelianGroup.Member add(AbelianGroup.Member g) {
116                         return new Member(i+((Member)g).i);
117                 }
118                 /**
119                 * Returns the inverse member.
120                 */
121                 public AbelianGroup.Member negate() {
122                         return new Member(-i);
123                 }
124                 /**
125                 * The group composition law with inverse.
126                 * @param g a group member
127                 */
128                 public AbelianGroup.Member subtract(AbelianGroup.Member g) {
129                         return new Member(i-((Member)g).i);
130                 }
131                 /**
132                 * The group composition law.
133                 * @param g a group member
134                 */
135                 public Semigroup.Member compose(Semigroup.Member g) {
136                         return new Member(i+((Member)g).i);
137                 }
138                 /**
139                 * Returns the inverse member.
140                 */
141                 public Group.Member inverse() {
142                         return new Member(-i);
143                 }
144         }
145 }
146
Popular Tags