List.java. List.java. Printed by Tom Smedsaas

Dec 17, 08 8:35 Page 1/2 /** class List * Representerar en länkad lista av godtyckliga objekt public class List { /** class ListNode * Noder i listor protected static class ListNode { protected Object data; protected ListNode next; ListNode(Object d, ListNode n) { data = d; next = n; return data.tostring(); List.java /** class ListException * Undantagsklass för List public static class ListException extends RuntimeException { public ListException(String msg) { super(msg); protected ListNode head; // Första noden i listan /** Constructors public List() { head = null; List.java Dec 17, 08 8:35 Page 2/2 * Skapar en textrepresentation av listan genom att * använda de lagrade objektens tostring metoder. Objekten * åtskiljs av blanktecken och hela listan innesluts * av hakparenteser ([]) /** get() * Tar bort det första elementet ur listan och returnerar * dess värde. * @throws ListException Om listan är tom public Object get() { /** remove() * Tar bort första förekomst av objektet o (definierat av * equals) ur listan. * @throws ListException Om objektet inte finns i listan public void remove(object o) { head = remove(o, head); /** Tar bort första förekomst av objekt o (definierat av * equals) ur nodföljden som börjar med l. * @return Första noden i den modifierade lista * @throws ListException Om objektet inte finns i följden protected static ListNode remove(object o, ListNode l) { /** length() * Beräknar längden av listan * @return listans längd public int length() { return length(head); protected static int length(listnode l) { if (l==null) return 0; return 1 + length(l.next); /** add(); * Lägger in ett nytt objekt först i listan public void add(object o) { head = new ListNode(o, head); /** tostring() Wednesday November 25, 2009 List.java 1/9

Dec 16, 08 16:36 Page 1/1 /** Class QueueTest * Testar Queue klassen public class QueueTest { public static void main(string[] args) { Queue q = new Queue(); for ( int i=1; i<=10; i++ ) q.add(new Integer(i)); q.get(); q.get(); System.out.println("Aktuell kö: " + q); while ( q.length()>0 ) System.out.print(q.get() + " "); System.out.println(); q.add(new Integer(42)); q.remove(new Integer(42)); /* Output: vranx$ java QueueTest Aktuell kö: [3 4 5 6 7 8 9 10] 3 4 5 6 7 8 9 10 Exception in thread "main" List$ListException: remove illegal for queue at Queue.remove(Queue.java:24) at QueueTest.main(QueueTest.java:20) vranx$ QueueTest.java Dec 16, 08 16:15 Page 1/4 /** Symbolisk kalkylator Förvillkor för alla parser metoder förutom main, run: Tokenizern positionerad till det första obehandlade token dvs till det token som står på tur att behandlas. Eftervillkor för alla parser metoder utom main, run och statement: Tokenizern positionerad till det första obehandlade token. import java.util.*; import java.io.*; import symbolic.*; Parser.java /** class Parser public class Parser { private StreamTokenizer st private TreeMap<String, Sexpr> map; private HashSet<String> commands; private HashSet<String> unaries; // SyntaxException public class SyntaxException extends RuntimeException { public SyntaxException(String msg) { super(msg); // Constructor public Parser() throws IOException { map = new TreeMap<String,Sexpr>(); unaries = new HashSet<String>(); commands = new HashSet<String>(); st = new StreamTokenizer( new BufferedReader( new InputStreamReader(System.in))); st.eolissignificant(true); st.ordinarychar( + ); st.ordinarychar( ); st.ordinarychar( / ); st.ordinarychar( * ); st.ordinarychar( ^ ); st.ordinarychar(! ); st.ordinarychar( \ ); st.ordinarychar( & ); st.ordinarychar( " ); {char c = " ; //To fool a2ps unaries.add("&"); unaries.add("\""); unaries.add(" "); unaries.add("exp"); unaries.add("log"); unaries.add("sin"); unaries.add("cos"); commands.add("quit"); commands.add("variables"); // main() public static void main(string [] args) throws IOException { Parser p = new Parser(); p.run(); Wednesday November 25, 2009 QueueTest.java, Parser.java 2/9

Dec 16, 08 16:15 Parser.java Page 2/4 // run() public void run() throws IOException { while (true) try { do { System.out.print("? "); while ( st.nexttoken() == st.tt_eol ); statement(); catch (SyntaxException e) { System.out.println("*** Syntax Error: " + e.getmessage()); while ( st.ttype!= st.tt_eol ) catch (EvaluationException e) { System.out.println("*** Eval Error: " + e.getmessage()); // statement() public void statement() throws IOException { if ( st.ttype==st.tt_word && commands.contains(st.sval) ) { command(); { Sexpr d = assignment(); System.out.println("Read : " + d); System.out.println("Evaluated : " + d.eval(map)); if ( st.ttype!= st.tt_eol ) throw new SyntaxException("Expected EOL but found: " + st); // command() public void command() throws IOException { if (st.sval.equals("quit") ) { System.out.println("Bye"); System.exit(0); if ( st.sval.equals("variables") ) { System.out.println("Variables: " + map); throw new SyntaxException("Unknown command: " + st); // assignment() public Sexpr assignment() throws IOException { Sexpr result = expression(); while ( st.ttype == = ) { if ( st.ttype!= st.tt_word ) throw new SyntaxException("Expected identifier but found: " + st); { result = new Assignment(result, new Variable(st.sval)); return result; // expression() public Sexpr expression() throws IOException { Sexpr sum = term(); while ( st.ttype == + st.ttype == ) { int oper = st.ttype; if (oper== + ) sum = new Addition(sum, term()); Parser.java Dec 16, 08 16:15 Page 3/4 sum = new Subtraction(sum, term()); return sum; // term() public Sexpr term() throws IOException {.. // factor() public Sexpr factor() throws IOException { Sexpr result = primary(); while ( st.ttype == \ ) { if ( st.ttype!= st.tt_word ) throw new SyntaxException("Expected identifier but found: " + st); { result = new Differentiation(result, new Variable(st.sval)); return result; // primary() public Sexpr primary() throws IOException { Sexpr result = null; if ( st.ttype == ( ) { // ( assignment ) result = assignment(); if ( st.ttype!= ) ) throw new SyntaxException("Expected ) but found " + st); if ( st.ttype == st.tt_number ) { // number result = new Constant(st.nval); { String op = "" + (char) st.ttype; if ( st.ttype == st.tt_word ) op = st.sval; if ( unaries.contains(op) ) { // unary result = unary(op); if ( st.ttype == st.tt_word ) { // identifier result = new Variable(op); { // error throw new SyntaxException("Unexpected: " + st); // factorial while ( st.ttype ==! ) { result = new Factorial(result); return result; // unary() public Sexpr unary(string op) throws IOException { if (op.equals(" ")) return new Uminus(primary()); if (op.equals("\"")) return new Quotation(primary()); if (op.equals("&")) Wednesday November 25, 2009 Parser.java 3/9

Dec 16, 08 16:15 Page 4/4 return new Evaluation(primary()); if (op.equals("sin")) return new Sin(primary()); if (op.equals("cos")) return new Cos(primary()); if (op.equals("exp")) return new Exp(primary()); if (op.equals("log")) return new Log(primary()); throw new SyntaxException("Undefined operator: " + op); Parser.java Klasshierarki.java Dec 17, 08 9:32 Page 1/7 /** class Sexpr public abstract class Sexpr { public abstract Sexpr eval(map<string, Sexpr> map); public abstract String getname(); throw new EvaluationException("Can not differentiate: " + getname()); public double getvalue() { throw new RuntimeException("Internal error: getvalue()"); return 100; public boolean isconstant() { return false; public boolean iszero() { return false; public boolean isone() { return false; public boolean equals(sexpr e) { return tostring().equals(e.tostring()); /** class Atom public abstract class Atom extends Sexpr { return getname(); /** class Unary public abstract class Unary extends Sexpr { protected final Sexpr argument; public Unary(Sexpr argument) { this.argument = argument; return 50; if ( argument.priority() <= priority() ) return getname() + "(" + argument.tostring() + ")"; Wednesday November 25, 2009 Parser.java, Klasshierarki.java 4/9

Dec 17, 08 9:32 Page 2/7 return getname() + " " + argument.tostring(); /** class Binary public abstract class Binary extends Sexpr { protected final Sexpr left, right; public Binary(Sexpr left, Sexpr right) { this.left = left; this.right = right; return 30; // Default for some binary operators.. /** class Addition public class Addition extends Binary { public Addition(Sexpr left, Sexpr right) { return Symbolic.add( left.eval(map), right.eval(map)); return "+"; Klasshierarki.java return Symbolic.add(left.diff(x), right.diff(x)); Dec 17, 08 9:32 Klasshierarki.java Page 3/7 return "="; return 0; /** class Constant public class Constant extends Atom { private final double value; public Constant(double value) { this.value = value; return this; return "" + value; return new Constant(0); public double getvalue() { return value; public boolean isconstant() { return true; public boolean iszero() { return value==0.0; return 10; /** class Assignment public class Assignment extends Binary { public Assignment(Sexpr left, Sexpr right) { Sexpr val = left.eval(map); map.put(right.getname(), val); return val; public boolean isone() { return value==1.0; /** class Cos public class Cos extends Unary { /** class Differentiation public class Differentiation extends Binary { public Differentiation(Sexpr left, Sexpr right) { Wednesday November 25, 2009 Klasshierarki.java 5/9

Klasshierarki.java Dec 17, 08 9:32 Page 4/7 Sexpr val = left.eval(map); return val.diff(right); Dec 17, 08 9:32 Klasshierarki.java Page 5/7 /** class EvaluationException public class EvaluationException extends RuntimeException { return " "; public EvaluationException(String msg) { super(msg); return 40; /** class Division public class Division extends Binary { public Division(Sexpr left, Sexpr right) { return Symbolic.divide(left.eval(map), right.eval(map)); return "/"; /** class Exp public class Exp extends Unary { public Exp(Sexpr argument) { super(argument); return Symbolic.exp(argument.eval(map)); return "exp"; return Symbolic.multiply(argument.diff(x), new Exp(x)); Sexpr numerator = Symbolic.subtract( Symbolic.multiply(left.diff(x), right), Symbolic.multiply(left, right.diff(x)) ); Sexpr denominator = Symbolic.multiply(right, right); return Symbolic.divide(numerator, denominator); return 30; /** class Factorial public class Factorial extends Unary {.. /** class Log public class Log extends Unary { /** class Multiplication public class Multiplication extends Binary { /** class Evaluation public class Evaluation extends Unary { public Evaluation(Sexpr argument) { super(argument);.. public Multiplication(Sexpr left, Sexpr right) { return Symbolic.multiply( left.eval(map), right.eval(map)); return "*"; return "&"; return Symbolic.add( Symbolic.multiply(left.diff(x), right), Symbolic.multiply(left, right.diff(x)) ); Wednesday November 25, 2009 Klasshierarki.java 6/9

Dec 17, 08 9:32 Page 6/7 return 30; Klasshierarki.java Dec 17, 08 9:32 Klasshierarki.java Page 7/7 /** class Variable public class Variable extends Atom { private final String ident; /** class Power public class Power extends Binary { public Power(Sexpr left, Sexpr right) { return Symbolic.power( left.eval(map), right.eval(map)); public Variable(String ident) { this.ident = ident;.. return ident; return "^"; return 30; if (ident.equals(x.getname())) return new Constant(1.); return new Constant(0.); /** class Quotation public class Quotation extends Unary { public Quotation(Sexpr argument) { super(argument);.. return "\""; /** class Sin public class Sin extends Unary { /** class Subtraction public class Subtraction extends Binary { /** class Uminus public class Uminus extends Unary { Wednesday November 25, 2009 Klasshierarki.java 7/9

Symbolic.java Dec 16, 08 16:16 Page 1/1 /** class Symbolic public class Symbolic { public static Sexpr add(sexpr a, Sexpr b) { public static Sexpr multiply(sexpr a, Sexpr b) { public static Sexpr subtract(sexpr a, Sexpr b) { public static Sexpr divide(sexpr a, Sexpr b) { Dec 16, 08 15:45 Page 1/2 /*************************************************************************** * queue.h typedef struct node { // Noder i kön void * data; struct node *next; node, *Node; cqueues.c public static Sexpr exp(sexpr x) { if ( x.isconstant() ) return new Constant( Math.exp(x.getValue()) ); return new Exp(x); public static Sexpr log(sexpr x) { public static Sexpr sin(sexpr x) { public static Sexpr cos(sexpr x) { public static Sexpr umin(sexpr x) { public static Sexpr factorial(sexpr x) { if ( x.isconstant() ) {.. return new Factorial(x); public static Sexpr power(sexpr x, Sexpr y) { if ( x.isconstant() ) return new Constant( Math.pow(x.getValue(), y.getvalue()) ); return new Power(x, y); typedef struct queue { // köpost Node first; Node last; Node current; queue, *Queue; Queue newqueue(); // Konstruktor int isempty(queue q); // 1 om kön tom, annars 0 void put(queue q, void *data); // Lagra ett element sist i kön void *get(queue q); // Ta ut och returnera första elementet void reset(queue q); // Initiera iteratorn int more(queue q); // 1 om fler element, annars 0 void *next(queue q); // returnerar aktuellt element och stegar fram /************************************************************************** * Testprogram för kö mekanismen #include <stdio.h> #include "queue.h" int main() { Queue q = newqueue(); put(q, "Tack"); put(q, "för"); put(q, "fisken"); // Iterera över kön reset(q); while (more(q)) { printf("%s ", (char *)next(q)); printf("\n\n"); // Ta ut elementen ur kön while (!isempty(q)) printf("%s ", (char *)get(q)); printf("\n"); return 0; /* Körresultat vranx$ gcc queuetest.c queue.c vranx$ a.out Tack för fisken! Tack för fisken! vranx$ Wednesday November 25, 2009 Symbolic.java, cqueues.c 8/9

Dec 16, 08 15:45 Page 2/2 /**************************************************************************** * queue.c implementationsfil för köer #include <stdlib.h> #include "queue.h" /** Initierar ett köobjekt med en tom kö. * Returnetat en pekare till det skapade kö objektet Queue newqueue() { Queue q = (Queue) malloc(sizeof(queue)); q >first = q >last = q >current = NULL; return q; /** Returnerar 1 om kön är tom, annars 0 int isempty(queue q) { return q >first == NULL; cqueues.c /** Skapar ett ett nytt element med data som innehåll sist i kön void put(queue q, void *data) {.. /** Om kön tom returneras NULL, annars tas det första elementet ur kön * och dessa data returneras void *get(queue q) { if ( q >first == NULL ) return NULL; { Node n = q >first; void *d = n >data; q >first = n >next; return d; /** Initierar iteratorn till det första elementet i kön eller NULL om kön tom void reset(queue q) { q >current = q >first; /** Returnerar 1 om iteratorn kommit förbi det sista elementet int more(queue q) { return q >current!=null; /** Returnerar värdet i det aktuella elementet. * Stegar fram iteratorn (om more(q)!=0) void *next(queue q) {.. Wednesday November 25, 2009 cqueues.c 9/9