001    package hw3;
002    
003    import java.util.Stack;
004    import java.util.Iterator;
005    
006    /**
007     * <b>RatPolyStack</B> is a mutable finite sequence of RatPoly objects.
008     * <p>
009     * Each RatPolyStack can be described by [p1, p2, ... ], where [] is an empty
010     * stack, [p1] is a one element stack containing the Poly 'p1', and so on.
011     * RatPolyStacks can also be described constructively, with the append
012     * operation, ':'. such that [p1]:S is the result of putting p1 at the front of
013     * the RatPolyStack S.
014     * <p>
015     * A finite sequence has an associated size, corresponding to the number of
016     * elements in the sequence. Thus the size of [] is 0, the size of [p1] is 1,
017     * the size of [p1, p1] is 2, and so on.
018     * <p>
019     */
020    public final class RatPolyStack implements Iterable<RatPoly> {
021    
022        private final Stack<RatPoly> polys;
023    
024        // Abstraction Function:
025        // Each element of a RatPolyStack, s, is mapped to the
026        // corresponding element of polys.
027        //
028        // RepInvariant:
029        // polys != null &&
030        // forall i such that (0 <= i < polys.size(), polys.get(i) != null
031    
032        /**
033         * @effects Constructs a new RatPolyStack, [].
034         */
035        public RatPolyStack() {
036            polys = new Stack<RatPoly>();
037            checkRep();
038        }
039    
040        /**
041         * Returns the number of RayPolys in this RatPolyStack.
042         *
043         * @return the size of this sequence.
044         */
045        public int size() {
046            // TODO: Fill in this method, then remove the RuntimeException
047            throw new RuntimeException("RatPolyStack->size() unimplemented!\n");
048        }
049    
050        /**
051         * Pushes a RatPoly onto the top of this.
052         *
053         * @requires p != null
054         * @modifies this
055         * @effects this_post = [p]:this
056         */
057        public void push(RatPoly p) {
058            // TODO: Fill in this method, then remove the RuntimeException
059            throw new RuntimeException("RatPolyStack->push() unimplemented!\n");
060        }
061    
062        /**
063         * Removes and returns the top RatPoly.
064         *
065         * @requires this.size() > 0
066         * @modifies this
067         * @effects If this = [p]:S then this_post = S
068         * @return p where this = [p]:S
069         */
070        public RatPoly pop() {
071            // TODO: Fill in this method, then remove the RuntimeException
072            throw new RuntimeException("RatPolyStack->pop() unimplemented!\n");
073        }
074    
075        /**
076         * Duplicates the top RatPoly on this.
077         *
078         * @requires this.size() > 0
079         * @modifies this
080         * @effects If this = [p]:S then this_post = [p, p]:S
081         */
082        public void dup() {
083            // TODO: Fill in this method, then remove the RuntimeException
084            throw new RuntimeException("RatPolyStack->dup() unimplemented!\n");
085        }
086    
087        /**
088         * Swaps the top two elements of this.
089         *
090         * @requires this.size() >= 2
091         * @modifies this
092         * @effects If this = [p1, p2]:S then this_post = [p2, p1]:S
093         */
094        public void swap() {
095            // TODO: Fill in this method, then remove the RuntimeException
096            throw new RuntimeException("RatPolyStack->swap() unimplemented!\n");
097        }
098    
099        /**
100         * Clears the stack.
101         *
102         * @modifies this
103         * @effects this_post = []
104         */
105        public void clear() {
106            // TODO: Fill in this method, then remove the RuntimeException
107            throw new RuntimeException("RatPolyStack->clear() unimplemented!\n");
108        }
109    
110        /**
111         * Returns the RatPoly that is 'index' elements from the top of the stack.
112         *
113         * @requires index >= 0 && index < this.size()
114         * @return If this = S:[p]:T where S.size() = index, then returns p.
115         */
116        public RatPoly getNthFromTop(int index) {
117            // TODO: Fill in this method, then remove the RuntimeException
118            throw new RuntimeException(
119                    "RatPolyStack->getNthFromTop() unimplemented!\n");
120        }
121    
122        /**
123         * Pops two elements off of the stack, adds them, and places the result on
124         * top of the stack.
125         *
126         * @requires this.size() >= 2
127         * @modifies this
128         * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p1 + p2
129         */
130        public void add() {
131            // TODO: Fill in this method, then remove the RuntimeException
132            throw new RuntimeException("RatPolyStack->add() unimplemented!\n");
133        }
134    
135        /**
136         * Subtracts the top poly from the next from top poly, pops both off the
137         * stack, and places the result on top of the stack.
138         *
139         * @requires this.size() >= 2
140         * @modifies this
141         * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p2 - p1
142         */
143        public void sub() {
144            // TODO: Fill in this method, then remove the RuntimeException
145            throw new RuntimeException("RatPolyStack->sub() unimplemented!\n");
146        }
147    
148        /**
149         * Pops two elements off of the stack, multiplies them, and places the
150         * result on top of the stack.
151         *
152         * @requires this.size() >= 2
153         * @modifies this
154         * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p1 * p2
155         */
156        public void mul() {
157            // TODO: Fill in this method, then remove the RuntimeException
158            throw new RuntimeException("RatPolyStack->mul() unimplemented!\n");
159        }
160    
161        /**
162         * Divides the next from top poly by the top poly, pops both off the stack,
163         * and places the result on top of the stack.
164         *
165         * @requires this.size() >= 2
166         * @modifies this
167         * @effects If this = [p1, p2]:S then this_post = [p3]:S where p3 = p2 / p1
168         */
169        public void div() {
170            // TODO: Fill in this method, then remove the RuntimeException
171            throw new RuntimeException("RatPolyStack->div() unimplemented!\n");
172        }
173    
174        /**
175         * Pops the top element off of the stack, differentiates it, and places the
176         * result on top of the stack.
177         *
178         * @requires this.size() >= 1
179         * @modifies this
180         * @effects If this = [p1]:S then this_post = [p2]:S where p2 = derivative
181         *          of p1
182         */
183        public void differentiate() {
184            // TODO: Fill in this method, then remove the RuntimeException
185            throw new RuntimeException(
186                    "RatPolyStack->differentiate() unimplemented!\n");
187        }
188    
189        /**
190         * Pops the top element off of the stack, integrates it, and places the
191         * result on top of the stack.
192         *
193         * @requires this.size() >= 1
194         * @modifies this
195         * @effects If this = [p1]:S then this_post = [p2]:S where p2 = indefinite
196         *          integral of p1 with integration constant 0
197         */
198        public void integrate() {
199            // TODO: Fill in this method, then remove the RuntimeException
200            throw new RuntimeException("RatPolyStack->integrate() unimplemented!\n");
201        }
202    
203        /**
204         * Returns an iterator of the elements contained in the stack.
205         *
206         * @return an iterator of the elements contained in the stack in order from
207         *         the bottom of the stack to the top of the stack.
208         */
209        public Iterator<RatPoly> iterator() {
210            return polys.iterator();
211        }
212    
213        /**
214         * Checks that the representation invariant holds (if any).
215         */
216        // Throws a RuntimeException if the rep invariant is violated.
217        private void checkRep() throws RuntimeException {
218            /*assert polys != null: "polys should never be null.";
219            for (RatPoly p : polys) {
220                    assert p != null: "polys should never contain a null element.";
221            }*/
222            
223            
224            if (polys == null) {
225                throw new RuntimeException("polys should never be null.");
226            }
227            for (RatPoly p : polys) {
228                if (p == null) {
229                    throw new RuntimeException(
230                            "polys should never contain a null element.");
231                }
232            }
233        }
234    }