diff --git a/.gitignore b/.gitignore index 241aba930125011ad94353beb8bed96865cc4ef8..18866d03b8a21f314266049883af96dfbe98e164 100644 --- a/.gitignore +++ b/.gitignore @@ -17,8 +17,8 @@ cp/ex05 cp/ex06 cp/ex07 cp/ex08 -cp/ex09 -cp/ex10 +#cp/ex09 +#cp/ex10 cp/ex11 cp/ex12 cp/exam @@ -26,5 +26,5 @@ cp/project1 # cp/project2 cp/project3 cp/project4 -cp/project5 +#cp/project5 cp/project6 diff --git a/cp/ex09/__init__.py b/cp/ex09/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0be31d7b89d2f11b47aac820746bfa405a05e636 --- /dev/null +++ b/cp/ex09/__init__.py @@ -0,0 +1 @@ +"""Exercises for week 9.""" diff --git a/cp/ex09/rectangle.py b/cp/ex09/rectangle.py new file mode 100644 index 0000000000000000000000000000000000000000..2ef08c734a79adb885101e34abf0a0bbc956859d --- /dev/null +++ b/cp/ex09/rectangle.py @@ -0,0 +1,77 @@ +"""The Rectangle-exercises 9.1-9.2.""" +import matplotlib.pyplot as plt + +class Point: + """A class that represents a Point. See Section 15.1.""" + +class Rectangle: + """A class that represents a Rectangle. See Section 15.3.""" + +def area(rectangle : Rectangle) -> float: + """Compute the area of a Rectangle-object. + + :param rectangle: A rectangle-object. Recall it has properties such as ``rectangle.width`` and ``rectangle.height``. + :return: The area of the rectangle. + """ + # TODO: 1 lines missing. + raise NotImplementedError("Compute the area here. Try to use the debugger if you are stuck.") + return a + +def make_a_rectangle(x, y, width, height): + """Create and return a new Rectangle-object. Look at Section 15.3 to see what fields it must possess. + + :param x: The x-position of the lower-left corner. + :param y: The y-position of the lower-left corner. + :param width: The width of the rectangle. + :param height: The height of the rectangle. + :return: A new Rectangle object. + """ + # TODO: 6 lines missing. + raise NotImplementedError("Create and return a Rectangle object here.") + return rect + +def split_rectangle(rectangle : Rectangle, horizontally : bool) -> list: + """Split the rectangle object into two. Either horizontally or vertically. + + For instance, if ``horizontally=True`` this function should return a list such as + ``[left_rectangle, right_rectangle]``. + + :param rectangle: A rectangle-object. + :param horizontally: If ``True`` the Rectangle is split horizontally otherwise vertically. + :return: A list with two Rectangle-objects. + """ + # TODO: 5 lines missing. + raise NotImplementedError("Implement function body") + return split + +def plot_rectangle(rectangle: Rectangle): + """Plot the rectangle using matplotlib. + + :param rectangle: The Rectangle to plot. + """ + # TODO: 5 lines missing. + raise NotImplementedError("Implement function body") + +def rectangle_inception(rectangle, n): + r"""Recursively generate a list of n+1 rectangles by applying split_rectangle n times. + + Note that the list should contain n+1 non-overlapping rectangles with the same total area as the original rectangle. + The function should begin with a horizontal split. + + :param rectangle: The initial rectangle to split. + :param n: How many recursive splits to apply + :return: A list of n+1 Rectangle-instances of the form ``[left, right_top, ...]`` + """ + # TODO: 3 lines missing. + raise NotImplementedError("Implement function body") + return rectangles + + +if __name__ == "__main__": + rectangles = rectangle_inception(make_a_rectangle(0, 0, 10, 10), 10) + for r in rectangles: + plot_rectangle(r) + # Optionally: Let's save the rectangle for later: + from cp import savepdf + savepdf("rectangles.pdf") # Save your pretty rectangles for later. + plt.show() diff --git a/cp/ex09/sinus.py b/cp/ex09/sinus.py new file mode 100644 index 0000000000000000000000000000000000000000..4a825efa183e43e85491efb0e5b3ef2441cb9616 --- /dev/null +++ b/cp/ex09/sinus.py @@ -0,0 +1,86 @@ +"""Project work for week 9, classes I.""" +import math + +class Sin: + """A class that represents the sinus-function, i.e. sin(x) where x can be any expression.""" + + +class Cos: + """A class that represents the cosine-function, i.e. cos(x) where x can be any expression.""" + + +class Variable: + """A class that represents a (named) variable such as ``x``, ``y``, ``x2``, etc.""" + + +def make_symbol(symbol : str) -> Variable: + """Create a new Variable object with the given name. + + If ``v = make_symbol(x)`` then ``v.symbol`` should be the string ``"x"``. + + :param symbol: The symbol this variable represents, e.g. ``"x"``. + :return: A new variable object. + """ + # TODO: 2 lines missing. + raise NotImplementedError("Implement function body") + return v + +def sine(arg : object) -> Sin: + """Create a new Sin object. The object will represent sin(arg). + + In other words, if we let ``s = sine(arg), then s.arg should be equal to ``arg``. In our case, + ``arg`` can be either a ``Variable``, or an object such as ``Sin``. + + :param arg: The argument to sin. + :return: An object representing ``sin(arg)``. + """ + # TODO: 2 lines missing. + raise NotImplementedError("Implement function body") + return s + +def cosine(arg : object) -> Cos: + """Create a new Cos object. The object will represent cos(arg). + + In other words, if we let ``s = cosine(arg), then s.arg should be equal to ``arg``. In our case, + ``arg`` can be either a ``Variable``, or an object such as ``Cos``. + + :param arg: The argument to cos. + :return: An object representing ``cos(arg)``. + """ + # TODO: 2 lines missing. + raise NotImplementedError("Implement function body") + return s + +def format_expression(expression : object) -> str: + """Format the given expression and return it as a string. + + The expression is an object either of class Variable, Sin or Cos. The function should format it as a ``str``. + + :param expression: An object to format. + :return: A string representation such as ``"cos(x)"`` or ``"sin(cos(y))"``. + """ + # TODO: 6 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + + +if __name__ == "__main__": + exp = sine(cosine(sine(sine(make_symbol('x'))))) + print( format_expression(exp) ) + # print(format_expression(exp), "evaluated in x=0 is", evaluate(exp, 0) ) + pass + + from sympy import sin, cos, symbols, evaluate, Symbol + evaluate_expression = sin.evalf # Get the evaluation-function. Ignore the right-hand side for now. + print_expression = sin.__str__ # Get the formatting-function. Ignore the right-hand side for now. + + x = symbols('x') # Define a symbol + y = sin(cos(x)) + print_expression(y) + evaluate_expression(y, subs={'x': 0}) + + y = sin(x) + isinstance(y, sin) # It is an instance of the sin-class + from sympy import Symbol + y.args + isinstance(y.args[0], Symbol) + y.args[0] == x diff --git a/cp/ex09/vector.py b/cp/ex09/vector.py new file mode 100644 index 0000000000000000000000000000000000000000..c4638a008026ce146510af666c1794775b8dde81 --- /dev/null +++ b/cp/ex09/vector.py @@ -0,0 +1,223 @@ +"""This file contains all the exercises relating to the Minecraft-example 9.3-9.8.""" +import matplotlib.pyplot as plt + +class Vector: + """A class that represents a Vector, defined by the endpoint :math:`(x,y)`.""" + + +def make_vector(x : float, y : float) -> Vector: + """Create a new Vector object with end-points :math:`(x,y)`. + + .. runblock:: pycon + + >>> from cp.ex09.vector import make_vector + >>> v = make_vector(2,3) + >>> v.x + >>> v.y + + :param x: The :math:`x`-position of the vector. + :param y: The :math:`y`-position of the vector. + :return: A Vector-object with the given end-point. + """ + # TODO: 3 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return v + +def print_vector(v: Vector): + """Print a vector object with coordinates (x,y) to the console. + + The output format for a vector with coordinates :math:`x, y` should be simply ``(x, y)`` (on a single line) + + :param v: A vector object instance. + """ + print(f"{(v.x, v.y)}") + +def dot(v1 : Vector, v2 : Vector) -> float: + r"""Compute the dot-product of ``v1`` and ``v2``, i.e. :math:`\mathbf{v}_1 \cdot \mathbf{v}_2`. + + :param v1: The first vector, + :param v2: The second vector, + :return: The dot product of ``v1`` and ``v2`` (as a ``float``) + """ + return v1.x * v2.x + v1.y * v2.y + +def scale(s : float, v : Vector) -> Vector: + r"""Scale the vector :math:`\mathbf{v}` by a factor of :math:`s`. + + :param s: A scalar number + :param v: A vector + :return: The vector :math:`s \mathbf{v}`. + """ + # TODO: 1 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return w + +def add(v1 : Vector, v2 : Vector) -> Vector: + r"""Add the two vectors ``v1`` and ``v2`` and return the sum as a ``Vector`` object. + + :param v1: The first vector, + :param v2: The second vector. + :return: Their sum :math:`\mathbf{v}_1+\mathbf{v}_2` + """ + return make_vector(v1.x + v2.x, v1.y+v2.y) + +def sub(v1 : Vector, v2 : Vector) -> Vector: + r"""Subtract the two vectors ``v1`` and ``v2`` and return the difference as a ``Vector`` object. + + :param v1: The first vector, + :param v2: The second vector. + :return: Their difference :math:`\mathbf{v}_1-\mathbf{v}_2` + """ + diff = add(v1, scale(-1, v2)) + return diff + + +def hat(v): + r"""Given a ``Vector`` v1, this function returns a new vector which is orthogonal to v1 ('Tværvektoren' in Danish). + + :param v: A vector :math:`\mathbf{v}`. + :return: A ``Vector`` that is orthogonal to :math:`\mathbf{v}`, i.e. :math:`\hat{\mathbf{v}}`. + """ + # TODO: 1 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return v_hat + +class LineSegment: + """A class that represents a line segment.""" + +def make_line_segment(p : Vector, q : Vector) -> LineSegment: + r"""Construct a ``LineSegment`` connecting the two vectors ``p`` and ``q``. + + Note you have some freedom in terms of how you wish to store ``p`` and ``q`` in the ``LineSegment`` object; + i.e. you can either store ``p`` and ``q`` directly similar to the ``Vector``, or perhaps do something slightly + smarter. + + :param p: The vector the line segments begins in + :param q: The line segment the vector ends in + :return: A LineSegment class representing the LineSegment. + """ + # TODO: 3 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return l + + +def point_on_line(l : LineSegment, t : float) -> Vector: + r"""Interpolate between the end-points of the LineSegment. + + Given a line segment, the function will interpolate between the end-points using :math:`t \in [0,1]` + and return a Vector. This can be used to compute any point on the LineSegment and :math:`t=0,1` will + correspond to the end-points. The order is not important for the following problems. + + :param l: A line defined by the two end-points vectors + :param t: Weighting of the two end-point in the inerpolation, :math:`t \in [0,1]`. + :return: A ``Vector`` corresponding to :math:`\mathbf{p} + (\mathbf{q}-\mathbf{p})t`. + """ + # TODO: 1 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return s + +def plot_vector(v: Vector): + """Plot a Vector using matplotlib. + + :param v: Vector to plot. + """ + plt.plot(v.x, v.y, 'ro') + +def plot_line(l : LineSegment): + r"""Plot a LineSegment using matplotlib. + + :param l: The line segment to plot + """ + p = point_on_line(l, 0) + q = point_on_line(l, 1) + plt.plot([p.x, q.x], [p.y, q.y], 'k-') + + +class SquareWithPosition: + """Corresponds to a square located in space. I.e., each corner has an :math:`(x,y)` coordinate.""" + +def make_square_with_position(x : float,y : float, width : float) -> SquareWithPosition: + r"""Create a ``SquareWithPosition`` instance with lower-left corner at :math:`(x,y)` and the given ``width``. + + Note: It is up to you how you want to store the information in the SquareWithLocation-class. You can for instance + choose to store the four corners as ``Vector``-objects, the four sides as ``LineSegment``-objects. + + :param x: :math:`x`-position of the lower-left corner + :param y: :math:`y`-position of the lower-left corner + :param width: The side-length of the rectangle + :return: A ``SquareWithLocation`` object. + """ + # TODO: 5 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return s + + +def intersect(l1: LineSegment, l2: LineSegment) -> Vector: + """Get the intersection between two line segments assuming they intersects. + + :param l1: First line + :param l2: Second line + :return: A ``Vector`` representing the point of intersection. + """ + # TODO: 1 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return p + +def do_they_intersect(l1 : LineSegment, l2 : LineSegment) -> bool: + """Determine if two line segments intersects. + + :param l1: First line segment + :param l2: Second line segment + :return: ``True`` if the two line segments intersects, otherwise ``False``. + """ + # TODO: 3 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return is_intersecting + + +def square_to_lines(sq : SquareWithPosition) -> list: + """Return a list of ``LineSegment``-objects corresponding to the four sides. + + :param sq: The square + :return: A list of four sides, ``[l1, l2, l3, l4]`` + """ + # TODO: 1 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return lines + +def plot_square(sq: SquareWithPosition): + """Plot the ``SquareWithLocation`` instance. + + :param sq: The square to plot + """ + # TODO: 2 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + +def get_intersections(sq : SquareWithPosition, l : LineSegment) -> list: + """Return a list of ``Vector``-objects corresponding to all intersections between the square and line segment. + + :param sq: A square + :param l: A line segment + :return: A list of 0, 1, or 2 ``Vector``-objects corresponding to the intersections. + """ + # TODO: 1 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + return intersections + +def plot_intersections(sq : SquareWithPosition, l : LineSegment): + """Plot all intersections between the square and line. + + :param sq: A square + :param l: A line segment + """ + # TODO: 2 lines missing. + raise NotImplementedError("Insert your solution and remove this error.") + +if __name__ == '__main__': + square = make_square_with_position(1,1,2) + line = make_line_segment(make_vector(-1, -1), make_vector(2, 4) ) + vec = make_line_segment(make_vector(1, 1), make_vector(3, 1) ) + plot_square(square) + plot_line(line) + plot_intersections(square, line) + plt.show() diff --git a/cp/ex10/__init__.py b/cp/ex10/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..24a53b8359da2d36ace8ec63be1da661c813dd7d --- /dev/null +++ b/cp/ex10/__init__.py @@ -0,0 +1 @@ +"""This package represents exercise 10.""" diff --git a/cp/ex10/hospital.py b/cp/ex10/hospital.py new file mode 100644 index 0000000000000000000000000000000000000000..21afd9e9ed33804bbbe62b223dd9547401c0b876 --- /dev/null +++ b/cp/ex10/hospital.py @@ -0,0 +1,20 @@ +"""Exercise 10.1: A hospital with doctors and patients.""" + +illnesses = {'hanging toenail': ('feets', 200), + 'stepped on lego': ('feets', 100), + 'headache': ('head', 100), + 'toothache': ('head', 200), + } + +class Person: + """A simple class that represents a person.""" + + # TODO: 20 lines missing. + + + +# TODO: 73 lines missing. + +if __name__ == "__main__": + p = Person("Patricia Smith", 24, 'f') # use the __init__-method to construct the person. + print(p) # Call the str-method diff --git a/cp/ex10/inherit.py b/cp/ex10/inherit.py new file mode 100644 index 0000000000000000000000000000000000000000..e48a3a8d25c1e277209032772e772844e972a0ac --- /dev/null +++ b/cp/ex10/inherit.py @@ -0,0 +1,58 @@ +"""A small example of how to use the super()-keyword.""" +class Pet: + """A basic Pet-class.""" + + def __init__(self, name, age): + """Create a new Pet object. + + :param name: The name of the Pet + :param age: The age of the Pet. + """ + self.name = name + self.age = age + + def __str__(self): + """ + Automatically called by ``print(..)``. + + :return: A string representation such as ``"Fido (3 years old)"``. + """ + return f"{self.name} ({self.age} years old)" + +class SimpleCat(Pet): + """A simple Cat-class. This example contains duplicated code.""" + + def __init__(self, name, age, favorite_food): + """Construct a new Cat-object. Asides the name and age, it also has a favorite food. + + :param name: The name of the cat, for instance ``'Mr. Whiskers'`` + :param age: The age, for instance 3. + :param favorite_food: The favorite food, for instance ``"fish"``. + """ + self.name = name + self.age = age + self.favorite_food = favorite_food + +class ImprovedCat(Pet): + """The ImprovedCat uses super() to avoid duplicate code.""" + + def __init__(self, name, age, favorite_food): + """Construct a new Cat-object. The example function similar to the one before. + + :param name: The name of the cat, for instance ``'Mr. Whiskers'`` + :param age: The age, for instance 3. + :param favorite_food: The favorite food, for instance ``"fish"``. + """ + super().__init__(name, age) # Call the Pet.__init__()-method. + self.favorite_food = favorite_food # We stll need to store this one. + + +if __name__ == "__main__": + a = SimpleCat("Mr. Whiskers", 3, "fish") + print(a) + print(a.favorite_food) + # Now let's make an improved cat. + + b = SimpleCat("Mr. Super-duper whiskers", 4, "whatever you are eating") + print(b) + print(b.favorite_food) diff --git a/cp/ex10/symbolic.py b/cp/ex10/symbolic.py new file mode 100644 index 0000000000000000000000000000000000000000..dde37fa80f0044229abfa26cc68131bd94ebc5b7 --- /dev/null +++ b/cp/ex10/symbolic.py @@ -0,0 +1,82 @@ +"""Project work for week 10: A do-it-yourself sympy.""" +import math + + +class Expression: + """A mathematical expression. Can represent a constant `1`, a symbol such as `x`, or a function such as `sin(x)`.""" + + def evaluate(self, substitutions : dict) -> float: + """Evaluate the expression and return a floating-point number. + + The input argument is a dictionary which is used to evaluate all symbols. E.g. if ``substitutions = {'x': 3}``, + this means all instances of the symbolic expression ``x`` will be replaced by ``3``. + + :param substitutions: A dictionary of substitutions. The keys are strings, and the values are numbers. + :return: A floating-point number this expression has been evaluated to. + """ + return 0 + + def differentiate(self, variable : str) -> 'Expression': + r"""Differentiate the expression with respect to the variable, specified as e.g. ``"x"``. + + Note that if this expression is a function of other variables, we must use the chain-rule to recursively + differentiate the other expressions. e.g. :math:`\sin(f(x))' = \cos(f(x))f'(x)`. + + :param variable: The variable we differentiate with respect to (example: ``"x"``) + :return: A class that inherits from ``Expression`` which corresponds to the derivative with respect to the given variable. + """ + return Expression() + + def __str__(self) -> str: + """Provide a string representation of the expression. The function is called automatically by ``print``. + + :return: A string representation of this expression. + """ + return "Remember to implement the __str__()-function." + +# TODO: 246 lines missing. + +if __name__ == "__main__": + # construct some symbolic expressions + c1 = Constant(2) + c2 = Constant(3) + v = Variable('x') + + # construct expression (2 * x + 3) + expr1 = Addition(Multiplication(c1, v), c2) + + print(expr1) + print(expr1.differentiate("x")) + + # let's evaluate this expression for x = 4 + print(expr1.evaluate( {'x': 4} )) # prints 11 + + # let's differentiate this expression with respect to x + # it should be (2 * 1 + 0) = 2 + diff_expr1 = expr1.differentiate('x') + + # evaluate the derivative at x = 4 + print(diff_expr1.evaluate( {'x': 2} )) # prints 2 + + + # construct another expression (x ^ 3) + expr2 = Sin(v) # Constant(3)) + + # let's evaluate this expression for x = 2 + print(expr2.evaluate( {'x': 2} )) # prints 8 + print(expr2) + # let's differentiate this expression with respect to x + # it should be 3 * x ^ 2 which equals 3 * 2 ^ 2 = 12 at x = 2 + diff_expr2 = expr2.differentiate('x') + print(diff_expr2) + + print( Sin(Cos(Cos(v))).differentiate('y') ) + + + # evaluate the derivative at x = 2 + print(diff_expr2.evaluate({'x': 2})) # prints 12 + + +# Doctor +# Person +# Patient diff --git a/cp/project0/project0_grade.py b/cp/project0/project0_grade.py index ff2b69460ef79b76e24cf24b5485d9ca05f55a7c..e14521af4858daac5a351859a8bce282075bdd7c 100644 --- a/cp/project0/project0_grade.py +++ b/cp/project0/project0_grade.py @@ -1,4 +1,4 @@ # cp/project0/project0_tests.py ''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. ''' import bz2, base64 -exec(bz2.decompress(base64.b64decode('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'))) \ No newline at end of file +exec(bz2.decompress(base64.b64decode('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'))) \ No newline at end of file diff --git a/cp/project0/unitgrade_data/HelloWorld.pkl b/cp/project0/unitgrade_data/HelloWorld.pkl index d17109b342d430f00a55ecf8f011318e4203a665..54b083884991dd290cd798f5c89162c6b466ddba 100644 Binary files a/cp/project0/unitgrade_data/HelloWorld.pkl and b/cp/project0/unitgrade_data/HelloWorld.pkl differ diff --git a/cp/project2/project2_grade.py b/cp/project2/project2_grade.py index b8c41514e065d584748b1421b346e4c708153bc4..103c75a7d485b6267ddd346ee7715f80da2cf820 100644 --- a/cp/project2/project2_grade.py +++ b/cp/project2/project2_grade.py @@ -1,4 +1,4 @@ # cp/project2/project2_tests.py ''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. ''' import bz2, base64 -exec(bz2.decompress(base64.b64decode('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'))) \ No newline at end of file +exec(bz2.decompress(base64.b64decode('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'))) \ No newline at end of file diff --git a/cp/project2/unitgrade_data/Hangman.pkl b/cp/project2/unitgrade_data/Hangman.pkl index 0449171945415fa54956698dc87e7a4e6661d330..64d8bef37cafe500d46024f4472658043f01342d 100644 Binary files a/cp/project2/unitgrade_data/Hangman.pkl and b/cp/project2/unitgrade_data/Hangman.pkl differ diff --git a/cp/project2/unitgrade_data/HangmanAvailableLetters.pkl b/cp/project2/unitgrade_data/HangmanAvailableLetters.pkl index 2f80d375222f88e36b7c6d3ef3826c2fc3d5ba83..dec8d1006fc74330adf0f84fe81f3ff5049ec3f9 100644 Binary files a/cp/project2/unitgrade_data/HangmanAvailableLetters.pkl and b/cp/project2/unitgrade_data/HangmanAvailableLetters.pkl differ diff --git a/cp/project2/unitgrade_data/HangmanGuessedWord.pkl b/cp/project2/unitgrade_data/HangmanGuessedWord.pkl index 9385a80765cfb21a58c92da7be7a4ffb8e2579dc..25fd0c2748c91d88dbf1929f28c3d8d478c4e004 100644 Binary files a/cp/project2/unitgrade_data/HangmanGuessedWord.pkl and b/cp/project2/unitgrade_data/HangmanGuessedWord.pkl differ diff --git a/cp/project2/unitgrade_data/HangmanIsGuessed.pkl b/cp/project2/unitgrade_data/HangmanIsGuessed.pkl index 743a6e7a95bf67909d6e543ba72f90d8b765bd9e..c8b7ee8adff7226a7b7e3ae610c73216bacb4595 100644 Binary files a/cp/project2/unitgrade_data/HangmanIsGuessed.pkl and b/cp/project2/unitgrade_data/HangmanIsGuessed.pkl differ diff --git a/cp/project2/unitgrade_data/TestBisect.pkl b/cp/project2/unitgrade_data/TestBisect.pkl index e0cfff84318938e08383f6d9ef02e303545eee9d..02866fc2e0f5598df2980bd35d8c3324a37bc87f 100644 Binary files a/cp/project2/unitgrade_data/TestBisect.pkl and b/cp/project2/unitgrade_data/TestBisect.pkl differ diff --git a/cp/project2/unitgrade_data/TestIsThereARoot.pkl b/cp/project2/unitgrade_data/TestIsThereARoot.pkl index da0342531da925c64d856a40491e09f4b709f154..1d69ae6c5b4dfd86b87b6f77f3a93f000b742a80 100644 Binary files a/cp/project2/unitgrade_data/TestIsThereARoot.pkl and b/cp/project2/unitgrade_data/TestIsThereARoot.pkl differ diff --git a/cp/project2/unitgrade_data/TestTheFunctionToBisect.pkl b/cp/project2/unitgrade_data/TestTheFunctionToBisect.pkl index 2b3fccec2e772d0de35946e79579ee8bc60399fa..90a7e974aaf97ec98a391adc1ff9074992909351 100644 Binary files a/cp/project2/unitgrade_data/TestTheFunctionToBisect.pkl and b/cp/project2/unitgrade_data/TestTheFunctionToBisect.pkl differ diff --git a/cp/project5/__init__.py b/cp/project5/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..890dc18eaf0fafeab3829fd71c6e5c41882a86cc --- /dev/null +++ b/cp/project5/__init__.py @@ -0,0 +1 @@ +"""Dummy (test) project from 02465.""" diff --git a/cp/project5/project5_grade.py b/cp/project5/project5_grade.py new file mode 100644 index 0000000000000000000000000000000000000000..87ff793d8cc5ff102519757d6cf25745c6fd878c --- /dev/null +++ b/cp/project5/project5_grade.py @@ -0,0 +1,4 @@ +# cp/project5/project5_tests.py +''' WARNING: Modifying, decompiling or otherwise tampering with this script, it's data or the resulting .token file will be investigated as a cheating attempt. ''' +import bz2, base64 +exec(bz2.decompress(base64.b64decode('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'))) \ No newline at end of file diff --git a/cp/project5/project5_tests.py b/cp/project5/project5_tests.py new file mode 100644 index 0000000000000000000000000000000000000000..43beb4cb7e345d4285a0d4eb075e4f3e8844c588 --- /dev/null +++ b/cp/project5/project5_tests.py @@ -0,0 +1,245 @@ +from unitgrade import UTestCase, Report, hide +import math + +class TestSineCosineWeek9(UTestCase): + def test_make_symbol(self): + from cp.ex09.sinus import make_symbol, Variable + v = make_symbol('x') + self.assertIsInstance(v, Variable) + + + + def test_sine(self): + from cp.ex09.sinus import make_symbol, sine, Sin + v = make_symbol('x') + s = sine(v) + self.assertIsInstance(s, Sin) + self.assertEqual(s.arg, v) + + + + def test_cosine(self): + from cp.ex09.sinus import make_symbol, cosine, Cos + v = make_symbol('x') + c = cosine(v) + self.assertIsInstance(c, Cos) + self.assertEqual(c.arg, v) + + + def test_format_expression(self): + from cp.ex09.sinus import make_symbol, sine, cosine, format_expression + v = make_symbol('x') + s = sine(v) + c = cosine(v) + self.assertEqual(format_expression(v), 'x') + self.assertEqual(format_expression(s), 'sin(x)') + self.assertEqual(format_expression(c), 'cos(x)') + + # Test nested expressions + s2 = sine(c) + c2 = cosine(s) + self.assertEqual(format_expression(s2), 'sin(cos(x))') + self.assertEqual(format_expression(c2), 'cos(sin(x))') + + +class TestConstant(UTestCase): + + def test_inheritance(self): + from cp.ex10.symbolic import Constant, Expression + c = Constant(7) + self.assertIsInstance(c, Expression) + + + def test_print(self): + from cp.ex10.symbolic import Constant + self.assertEqual(str(Constant(7)), "7") + self.assertEqual(str(Constant(0)), "0") + self.assertEqual(str(Constant(3.14)), "3.14") + + + + def test_negative_print(self): + from cp.ex10.symbolic import Constant + self.assertEqual(str(Constant(-101)), "(-101)") + + + def test_evaluate(self): + from cp.ex10.symbolic import Constant + c = Constant(7) + self.assertEqual(c.evaluate({}), 7) + self.assertEqual(c.evaluate({"z": -10}), 7) + + + + def test_derivative(self): + from cp.ex10.symbolic import Constant + c = Constant(7) + d = c.differentiate("x") + self.assertIsInstance(d, Constant) + self.assertEqual(d.evaluate({}), 0) + + +class TestVariable(UTestCase): + def test_inheritance(self): + from cp.ex10.symbolic import Variable, Expression + self.assertIsInstance(Variable("x"), Expression) + + + def test_print(self): + from cp.ex10.symbolic import Variable + self.assertEqual(str(Variable("x")), "x") + + + def test_evaluate(self): + from cp.ex10.symbolic import Variable + c = Variable("x") + self.assertEqual(c.evaluate({"x": 7}), 7) + + + def test_derivative(self): + from cp.ex10.symbolic import Variable, Constant + c = Variable("x") + d = c.differentiate("x") + self.assertIsInstance(d, Constant) + self.assertEqual(str(d), "1") + + +class TestAddition(UTestCase): + def test_inheritance(self): + from cp.ex10.symbolic import Addition, Constant, BinaryOperator + self.assertIsInstance(Addition(Constant(1), Constant(2)), BinaryOperator) + + + def test_print(self): + from cp.ex10.symbolic import Addition, Variable + self.assertEqual(str(Addition(Variable("x"), Variable("y"))), "(x + y)") + + + def test_evaluate(self): + from cp.ex10.symbolic import Addition, Constant, Variable + c = Addition(Variable("x"), Constant(3)) + self.assertEqual(c.evaluate({"x": 7}), 10) + + + + def test_derivative(self): + from cp.ex10.symbolic import Addition, Constant, Variable + c = Addition(Variable("x"), Constant(3)) + d = c.differentiate("x") + self.assertEqual(str(d), "(1 + 0)") + self.assertEqual(d.evaluate({}), 1) + + + def test_derivative_nested(self): + from cp.ex10.symbolic import Addition, Constant, Variable + c = Addition(Variable("x"), Addition(Constant(3), Variable("x"))) + d = c.differentiate("x") + self.assertEqual(str(d), "(1 + (0 + 1))") + + +class TestMultiplication(UTestCase): + def test_print(self): + from cp.ex10.symbolic import Multiplication, Constant, Variable + self.assertEqual(str(Multiplication(Variable("x"), Constant(3))), "x * 3") + + + + def test_evaluate(self): + from cp.ex10.symbolic import Multiplication, Constant, Variable + self.assertEqual(Multiplication(Variable("x"), Constant(3)).evaluate({"x": 2}), 6) + + + def test_derivative(self): + from cp.ex10.symbolic import Multiplication, Constant, Variable + c = Multiplication(Variable("x"), Constant(3)) + d = c.differentiate("x") + self.assertEqual(str(d), "(1 * 3 + x * 0)") + self.assertEqual(d.evaluate({"x": 10}), 3) + + + + def test_derivative_nested(self): + from cp.ex10.symbolic import Multiplication, Constant, Variable, Addition + c = Multiplication(Variable("x"), Addition(Constant(3), Variable("x"))) + d = c.differentiate("x") + self.assertEqual(str(d), "(1 * (3 + x) + x * (0 + 1))") + + +class TestTrigonometricBasic(UTestCase): + def test_sin_print(self): + from cp.ex10.symbolic import Variable, Sin + sin = Sin(Variable("x")) + self.assertEqual(str(sin), "sin(x)") + + + def test_cos_print(self): + from cp.ex10.symbolic import Constant, Cos + cos = Cos(Constant(3)) + self.assertEqual(str(cos), "cos(3)") + + + + def test_sin_evaluate(self): + from cp.ex10.symbolic import Variable, Sin + sin = Sin(Variable("x")) + self.assertAlmostEqual(sin.evaluate({"x": 2}), math.sin(2)) + + + def test_cos_evaluate(self): + from cp.ex10.symbolic import Variable, Cos + self.assertAlmostEqual(Cos(Variable("x")).evaluate({"x": 2}), math.cos(2)) + + + +class TestEverything(UTestCase): + def test_everything(self): + from cp.ex10.symbolic import Variable, Cos, Multiplication, Sin, Addition, Constant + x = Variable("x") + y = Addition( Multiplication(Constant(3), Sin(x)), Cos(x)) + str(y) + self.assertEqual(str(y), '(3 * sin(x) + cos(x))') + self.assertAlmostEqual(y.evaluate({"x": math.pi/2}), 3) + self.assertEqual(str(y.differentiate("x")), '((0 * sin(x) + 3 * cos(x) * 1) + (-1) * sin(x) * 1)') + + +class TestTrigonometricDerivative(UTestCase): + def test_sin(self): + from cp.ex10.symbolic import Variable, Sin + x = Variable("x") + dx = Sin(x).differentiate("x") + self.assertEqual(str(dx), "cos(x) * 1") + + def test_cos(self): + from cp.ex10.symbolic import Variable, Cos + x = Variable("x") + dx = Cos(x).differentiate("x") + self.assertEqual(str(dx), "(-1) * sin(x) * 1") + + def test_sin_advanced(self): + from cp.ex10.symbolic import Variable, Cos, Constant, Multiplication, Addition + x = Variable("x") + dx = Multiplication(x, Cos(Addition(x, Constant(3)))).differentiate("x") + self.assertEqual(str(dx), "(1 * cos((x + 3)) + x * (-1) * sin((x + 3)) * (1 + 0))") + + +class Project5(Report): + title = "Project 5" + remote_url = "https://cp.pages.compute.dtu.dk/02002public/_static/evaluation/" + + abbreviate_questions = True + questions = [(TestSineCosineWeek9, 20), + (TestConstant, 10), + (TestVariable, 10), + (TestAddition, 10), + (TestMultiplication, 10), + (TestTrigonometricBasic, 10), + (TestTrigonometricDerivative, 10), + (TestEverything, 10), + ] + import cp + pack_imports = [cp] + + +if __name__ == "__main__": + from unitgrade import evaluate_report_student + evaluate_report_student(Project5()) diff --git a/cp/project5/unitgrade_data/TestAddition.pkl b/cp/project5/unitgrade_data/TestAddition.pkl new file mode 100644 index 0000000000000000000000000000000000000000..80f2d1b45ec77856c88d5b3307eef59534e96467 Binary files /dev/null and b/cp/project5/unitgrade_data/TestAddition.pkl differ diff --git a/cp/project5/unitgrade_data/TestConstant.pkl b/cp/project5/unitgrade_data/TestConstant.pkl new file mode 100644 index 0000000000000000000000000000000000000000..e830161539fd09c2857c99adb37dadce176111cb Binary files /dev/null and b/cp/project5/unitgrade_data/TestConstant.pkl differ diff --git a/cp/project5/unitgrade_data/TestEverything.pkl b/cp/project5/unitgrade_data/TestEverything.pkl new file mode 100644 index 0000000000000000000000000000000000000000..fe6723ee0e3a73c0556b7afe4a2a3531c7713c2d Binary files /dev/null and b/cp/project5/unitgrade_data/TestEverything.pkl differ diff --git a/cp/project5/unitgrade_data/TestMultiplication.pkl b/cp/project5/unitgrade_data/TestMultiplication.pkl new file mode 100644 index 0000000000000000000000000000000000000000..a6d9641ce3dc2304a63aa540a907c682770ad6f9 Binary files /dev/null and b/cp/project5/unitgrade_data/TestMultiplication.pkl differ diff --git a/cp/project5/unitgrade_data/TestSineCosineWeek9.pkl b/cp/project5/unitgrade_data/TestSineCosineWeek9.pkl new file mode 100644 index 0000000000000000000000000000000000000000..3695c80eee2afb4af64d20a17428d3561ffa106f Binary files /dev/null and b/cp/project5/unitgrade_data/TestSineCosineWeek9.pkl differ diff --git a/cp/project5/unitgrade_data/TestTrigonometricBasic.pkl b/cp/project5/unitgrade_data/TestTrigonometricBasic.pkl new file mode 100644 index 0000000000000000000000000000000000000000..bf0430c5747fccffd252807e8e06654d8f140094 Binary files /dev/null and b/cp/project5/unitgrade_data/TestTrigonometricBasic.pkl differ diff --git a/cp/project5/unitgrade_data/TestTrigonometricDerivative.pkl b/cp/project5/unitgrade_data/TestTrigonometricDerivative.pkl new file mode 100644 index 0000000000000000000000000000000000000000..7cbdb58ddbdbd9aac468b95e80fe16a38ce25457 Binary files /dev/null and b/cp/project5/unitgrade_data/TestTrigonometricDerivative.pkl differ diff --git a/cp/project5/unitgrade_data/TestVariable.pkl b/cp/project5/unitgrade_data/TestVariable.pkl new file mode 100644 index 0000000000000000000000000000000000000000..76b16ff810f6701d775c012e16dcf8c8f065c8d8 Binary files /dev/null and b/cp/project5/unitgrade_data/TestVariable.pkl differ diff --git a/cp/tests/tests_week00.py b/cp/tests/tests_week00.py index eb0bc3ed6e174ce972c7a32aae7967c41020c543..9dcdf751eb3ec06614270c4cce219ac0cf12729d 100644 --- a/cp/tests/tests_week00.py +++ b/cp/tests/tests_week00.py @@ -3,36 +3,27 @@ import cp import io import unittest from unittest.mock import patch -import importlib -from cp.ex00 import say_hello - - -class HelloWorld2(UTestCase): +class SayHelloWorld(UTestCase): @unittest.mock.patch('sys.stdout', new_callable=io.StringIO) - def test_say_hello2(self, mock_stdout): - # from cp.ex00 import say_hello - - lib = importlib.reload(say_hello) + def test_say_hello(self, mock_stdout): + import cp.ex00.say_hello lines = mock_stdout.getvalue().strip().splitlines() - - self.assertEqual(len(lines), 2, msg=f"Wrong number of lines. Your program should print(..) out two lines, you got: {lines}, {say_hello.__file__}") + self.assertEqual(len(lines), 2, msg=f"Wrong number of lines. Your program should print(..) out two lines, you got: {lines}") print("Testing the first line") self.assertEqual(lines[0], "Hello", msg="You must have somehow changed the first print(...) statement in the program. Did you delete it?") # Rem print("Testing the second line") - self.assertEqual(lines[1], "World", msg="Your second print statement did not produce the correct output.") # Remember the output must be capitalized. + self.assertEqual(lines[1], "World", msg="Your second print statement did not produce the correct output.") class Week00Tests(Report): - title = "Tests for week 00 (Try to complete these before the course start)" + title = "Tests for week 00 (Try to complete this before the course start)" version = 1.0 url = "https://gitlab.compute.dtu.dk/cp/02002students/-/blob/master/cp/tests" - pack_imports = [cp] individual_imports = [] - questions = [ - (HelloWorld2, 10), - ] + questions = [(SayHelloWorld, 10)] + if __name__ == '__main__': from unitgrade import evaluate_report_student diff --git a/cp/tests/tests_week03.py b/cp/tests/tests_week03.py index 87adc657d6498431ad596320223ba2edf227f3f8..692daba5e3ad9f4a17b649c4444264f64c390b91 100644 --- a/cp/tests/tests_week03.py +++ b/cp/tests/tests_week03.py @@ -1,7 +1,7 @@ -from unitgrade import Report +from unitgrade import UTestCase, Report +import unittest.mock +import io import cp -from unitgrade import UTestCase - class Week03CompareNumbers(UTestCase): def test_compare_numbers(self): @@ -70,9 +70,7 @@ class Week03BACCalculator(UTestCase): result = bac_calculator(0.021, 70., "female", 2.) self.assertEqual(result,0.020545454545454547) - class AckermannTestCase(UTestCase): - def test_ackermann(self): from cp.ex03.ackermann import ackermann self.assertEqual(ackermann(0, 0), 1) @@ -86,11 +84,8 @@ class AckermannTestCase(UTestCase): self.assertEqual(ackermann(3, 0), 5) self.assertEqual(ackermann(3, 1), 13) self.assertEqual(ackermann(3, 2), 29) - # Add more test cases as needed - class ExponentialTestCase(UTestCase): - def test_exponential_with_positive_power(self): from cp.ex03.exponential import exponential self.assertEqual(exponential(2, 0), 1.0) @@ -98,7 +93,6 @@ class ExponentialTestCase(UTestCase): self.assertEqual(exponential(2, 2), 4.0) self.assertEqual(exponential(3, 3), 27.0) self.assertEqual(exponential(5, 4), 625.0) - # Add more test cases as needed def test_exponential_with_negative_power(self): from cp.ex03.exponential import exponential @@ -106,14 +100,12 @@ class ExponentialTestCase(UTestCase): self.assertEqual(exponential(2, -2), 0.25) self.assertAlmostEqual(exponential(3, -3), 0.037037037037) self.assertAlmostEqual(exponential(5, -4), 5**(-4) ) - # Add more test cases as needed def test_exponential_with_zero_power(self): from cp.ex03.exponential import exponential self.assertEqual(exponential(2, 0), 1.0) self.assertEqual(exponential(3, 0), 1.0) self.assertEqual(exponential(5, 0), 1.0) - # Add more test cases as needed class HeartAttackTests(UTestCase): @@ -129,9 +121,6 @@ class HeartAttackTests(UTestCase): self.assertEqual(heart_attack(45, 70, True), "high") self.assertEqual(heart_attack(11, 70, True), "high") - -import unittest.mock -import io class SolarPanelTests(UTestCase): @unittest.mock.patch('sys.stdout', new_callable=io.StringIO) def test_maybe(self, mock_stdout): @@ -171,7 +160,7 @@ class SolarPanelTests(UTestCase): self.assertEqual(out.strip().lower(), "sure") -class Week03Tests(Report): #40 total. +class Week03Tests(Report): title = "Tests for week 03" version = 1.0 url = "https://gitlab.compute.dtu.dk/cp/02002students/-/blob/master/cp/tests" diff --git a/cp/tests/tests_week04.py b/cp/tests/tests_week04.py index dc118607a638cf3fbea375b6a05352eded195a40..9d5828195c63b93a6d515250e94938a02536aac9 100644 --- a/cp/tests/tests_week04.py +++ b/cp/tests/tests_week04.py @@ -1,11 +1,8 @@ -from unitgrade import Report -import cp -from unitgrade import UTestCase +from unitgrade import UTestCase, Report import unittest +from unittest.mock import patch +import cp import io -import unittest -from unittest.mock import patch, call - class Palindrome(UTestCase): def test_is_palindrome(self): @@ -18,7 +15,6 @@ class Palindrome(UTestCase): class Bug(UTestCase): - @unittest.mock.patch('sys.stdout', new_callable=io.StringIO) def test_nice_sign(self, mock_stdout): from cp.ex04.bug import nice_sign @@ -49,8 +45,8 @@ class Bug(UTestCase): self.assertEqual(l2, "| I have written my last bug |") self.assertEqual(l3, "------------------------------") -class Math(UTestCase): +class Math(UTestCase): def test_square_root(self): from cp.ex04.mathematics import square_root self.assertAlmostEqual(square_root(9), 3, places=3) @@ -62,7 +58,6 @@ class Math(UTestCase): class Parenthesis(UTestCase): - def test_matching(self): from cp.ex04.parenthesis import matching self.assertTrue(matching('3x(y+x)')) @@ -105,6 +100,7 @@ class Dialogue(UTestCase): out = mock_stdout.getvalue() self.assertEqual(out.strip(), "How are you doing?\nStill stuck on my 02002 programming problems") + class Prefix(UTestCase): def test_common_prefix(self): from cp.ex04.prefix import common_prefix @@ -125,7 +121,6 @@ class Week04Tests(Report): version = 1.0 url = "https://gitlab.compute.dtu.dk/cp/02002students/-/blob/master/cp/tests" pack_imports = [cp] - questions = [ (Math, 10), (Palindrome, 10), diff --git a/cp/tests/tests_week09.py b/cp/tests/tests_week09.py index d4e7abeea8e311dc38ba1026c93de145382c11f9..5155e70f0a0146bd6c92363845931fac8cb23d02 100644 --- a/cp/tests/tests_week09.py +++ b/cp/tests/tests_week09.py @@ -1,13 +1,8 @@ -from unitgrade import Report -import cp -from unitgrade import UTestCase +from unitgrade import Report, UTestCase import unittest -from cp.ex09.vector import Vector, make_vector, print_vector, dot, scale, add, sub, hat, make_line_segment, point_on_line, LineSegment -# from cp.ex09.vector import make_vector, make_square_with_position, square_to_lines, intersect, do_they_intersect, get_intersections -from cp.ex09.vector import make_vector, make_square_with_position, square_to_lines, intersect, do_they_intersect, get_intersections -from cp.ex09.vector import make_line_segment +from unittest.mock import patch +import cp import io -from unittest.mock import patch, call class TestRectangleArea(UTestCase): def test_area(self): @@ -44,7 +39,7 @@ class TestMakeARectangle(UTestCase): class TestSplitRectangle(UTestCase): def setUp(self): - from cp.ex09.rectangle import make_a_rectangle, Rectangle, Point + from cp.ex09.rectangle import make_a_rectangle self.rectangle = make_a_rectangle(0, 0, 4, 6) def test_split_horizontally(self): @@ -78,15 +73,16 @@ class TestSplitRectangle(UTestCase): class TestRectangleInception(UTestCase): def test_inception_areas(self): - from cp.ex09.rectangle import make_a_rectangle, Rectangle, Point, rectangle_inception, area + from cp.ex09.rectangle import make_a_rectangle, rectangle_inception, area r = make_a_rectangle(2, 4, 12, 16) rs = rectangle_inception(r, 4) areas = [area(r_) for r_ in rs] self.assertEqual(len(areas), 5) self.assertEqual(areas, [96.0, 48.0, 24.0, 12.0, 12.0]) + def test_inception_location(self): - from cp.ex09.rectangle import make_a_rectangle, Rectangle, Point, rectangle_inception, area + from cp.ex09.rectangle import make_a_rectangle, Rectangle, rectangle_inception rs = rectangle_inception(make_a_rectangle(2, 4, 12, 16), 4) r = rs[-1] self.assertIsInstance(r, Rectangle) @@ -96,8 +92,9 @@ class TestRectangleInception(UTestCase): self.assertEqual(r.height, 4) class TestMakeVector(UTestCase): - def test_make_vector(self): + from cp.ex09.vector import Vector, make_vector + v1 = make_vector(2,3) self.assertIsInstance(v1, Vector, msg="Must return a Vector instance.") self.assertEqual(v1.x, 2) @@ -105,6 +102,8 @@ class TestMakeVector(UTestCase): @unittest.mock.patch('sys.stdout', new_callable=io.StringIO) def test_print_vector(self, mock_stdout): + from cp.ex09.vector import make_vector, print_vector + v1 = make_vector(2, 3) print_vector(v1) out = mock_stdout.getvalue().strip() @@ -112,11 +111,13 @@ class TestMakeVector(UTestCase): class TestVectorOperations(UTestCase): def test_dot_product(self): + from cp.ex09.vector import make_vector, dot v1 = make_vector(2,3) v2 = make_vector(4,5) self.assertEqual(dot(v1, v2), 23) def test_scale(self): + from cp.ex09.vector import make_vector, scale v = make_vector(2,3) s = 2 v_scaled = scale(s, v) @@ -124,6 +125,7 @@ class TestVectorOperations(UTestCase): self.assertEqual(v_scaled.y, 6) def test_add(self): + from cp.ex09.vector import make_vector, add v1 = make_vector(2,3) v2 = make_vector(4,5) v_sum = add(v1, v2) @@ -131,6 +133,7 @@ class TestVectorOperations(UTestCase): self.assertEqual(v_sum.y, 8) def test_subtract(self): + from cp.ex09.vector import make_vector, sub v1 = make_vector(2,3) v2 = make_vector(4,5) v_sub = sub(v1, v2) @@ -138,6 +141,7 @@ class TestVectorOperations(UTestCase): self.assertEqual(v_sub.y, -2) def test_hat(self): + from cp.ex09.vector import make_vector, hat v = make_vector(2,3) v_hat = hat(v) self.assertEqual(v_hat.x, -3) @@ -146,6 +150,7 @@ class TestVectorOperations(UTestCase): class TestLineSegmentMethods(UTestCase): def test_make_line_segment(self): + from cp.ex09.vector import make_vector, make_line_segment, LineSegment p = make_vector(1, 2) q = make_vector(3, 4) l = make_line_segment(p, q) @@ -153,6 +158,7 @@ class TestLineSegmentMethods(UTestCase): def test_point_on_line(self): + from cp.ex09.vector import make_vector, make_line_segment, Vector, point_on_line p = make_vector(1, 2) q = make_vector(3, 4) l = make_line_segment(p, q) @@ -164,33 +170,30 @@ class TestLineSegmentMethods(UTestCase): self.assertEqual(point_on_line(l, 1).y, q.y) def test_point_on_line_midpoint(self): + from cp.ex09.vector import make_vector, make_line_segment, point_on_line p = make_vector(1, 2) q = make_vector(3, 4) l = make_line_segment(p, q) - self.assertEqual(point_on_line(l, .5).x, (p.x+q.x)/2) self.assertEqual(point_on_line(l, .5).y, (p.y+q.y)/2) -from cp.ex09.vector import SquareWithPosition - class SquareWithLocationTests(UTestCase): def test_make_square(self): + from cp.ex09.vector import SquareWithPosition, make_square_with_position sq = make_square_with_position(1, 2, 3) self.assertIsInstance(sq, SquareWithPosition) def test_square_to_lines(self): + from cp.ex09.vector import make_square_with_position, square_to_lines, LineSegment, point_on_line sq = make_square_with_position(1, 2, 3) lines = square_to_lines(sq) self.assertIsInstance(lines, list, msg="Must return a list") self.assertEqual(len(lines), 4, msg="Must return 4 lines") for l in lines: self.assertIsInstance(l, LineSegment, msg="Must return 4 line segments") - # get all end-points: - tpl = lambda v: (v.x, v.y) lmd = lambda l: tuple( set( (tpl(point_on_line(l, 0) ), tpl(point_on_line(l, 1) )) ) ) l2 = list( set( [lmd(l) for l in lines] ) ) - self.assertEqual(l2[0], ((4,5), (1, 5)), msg="Problem with first line. It should connect points (4,5) -- (1, 5)") self.assertEqual(l2[1], ((1, 2), (4, 2))) self.assertEqual(l2[2], ((1, 2), (1, 5))) @@ -198,7 +201,7 @@ class SquareWithLocationTests(UTestCase): class TestIntersection(UTestCase): def test_do_they_intersect(self): - from cp.ex09.vector import make_vector, make_line_segment, do_they_intersect, intersect, print_vector + from cp.ex09.vector import make_vector, make_line_segment, do_they_intersect l1 = make_line_segment(make_vector(1, 1), make_vector(4, 1)) l2 = make_line_segment(make_vector(2, -2), make_vector(2, 3)) @@ -211,7 +214,7 @@ class TestIntersection(UTestCase): self.assertFalse(do_they_intersect(l3, l1), msg="Reverse order; lines should still not intersect") def test_intersect(self): - from cp.ex09.vector import make_vector, make_line_segment, do_they_intersect, intersect, print_vector + from cp.ex09.vector import make_vector, make_line_segment, intersect l1 = make_line_segment(make_vector(1, 1), make_vector(4, 1)) l2 = make_line_segment(make_vector(2, -2), make_vector(2, 3)) isect = intersect(l1, l2) @@ -220,6 +223,8 @@ class TestIntersection(UTestCase): class GetAllIntersections(UTestCase): def test_get_intersections_none(self): + from cp.ex09.vector import make_line_segment + from cp.ex09.vector import make_vector, make_square_with_position, get_intersections sq = make_square_with_position(1, 1, 6) l = make_line_segment(make_vector(-1, 2), make_vector(0, 0.5)) intersections = get_intersections(sq, l) @@ -227,8 +232,7 @@ class GetAllIntersections(UTestCase): self.assertEqual(len(intersections), 0) def test_get_intersections_one(self): - # from cp.ex09.vector import make_vector, make_line_segment, make_square_with_position, get_intersections - # from cp.ex09.vector import plot_point, plot_line, plot_square + from cp.ex09.vector import make_vector, make_square_with_position, get_intersections, make_line_segment sq = make_square_with_position(1, 1, 6) l = make_line_segment(make_vector(-1, 2), make_vector(4, 3)) intersections = get_intersections(sq, l) @@ -237,13 +241,11 @@ class GetAllIntersections(UTestCase): self.assertAlmostEqual(intersections[0].y, 2.4) def test_get_intersections_two(self): - # from cp.ex09.vector import make_vector, make_line_segment, make_square_with_position, get_intersections - # from cp.ex09.vector import plot_point, plot_line, plot_square + from cp.ex09.vector import make_line_segment, make_vector, make_square_with_position, get_intersections sq = make_square_with_position(1, 1, 6) l = make_line_segment(make_vector(-1, 2), make_vector(9, 4)) ls = get_intersections(sq, l) self.assertEqual(len(ls), 2) - ls = list(set([(ls[0].x, ls[0].y), (ls[1].x, ls[1].y)])) self.assertAlmostEqual(ls[0][0], 1, msg="testing x-coordinate of first point") @@ -252,10 +254,6 @@ class GetAllIntersections(UTestCase): self.assertAlmostEqual(ls[1][0], 7, msg="testing x-coordinate of second point") self.assertAlmostEqual(ls[1][1], 3.6, msg="testing y-coordinate of second point") - - - - class Week09Tests(Report): title = "Tests for week 09" version = 1.0 diff --git a/cp/tests/tests_week10.py b/cp/tests/tests_week10.py index 22674c65fd50a38b83521109de7812f4022e6b53..cdc9f6cfb5521c4fbd8c6a9216bef7ede30b64db 100644 --- a/cp/tests/tests_week10.py +++ b/cp/tests/tests_week10.py @@ -1,16 +1,9 @@ -from unitgrade import Report +from unitgrade import UTestCase, Report import cp -from unitgrade import UTestCase - class TestPerson(UTestCase): - # Test Person class def test_init(self): from cp.ex10.hospital import Person - # person = Person("John Doe", 35, "m") - # self.assertEqual(person.name, "John Doe") - # self.assertEqual(person.age, 35) - # self.assertEqual(person.gender, "m") self.assertRaises(ValueError, Person, "John Doe", 35, "z") def test_str(self): @@ -69,8 +62,6 @@ class TestDoctor(UTestCase): patient = Patient("John Doe", 35, "m", "toothache") self.assertEqual(doctor.treatment_cost(patient), 200) - - class Week10Tests(Report): title = "Tests for week 10" version = 1.0 diff --git a/cp/tests/unitgrade_data/AckermannTestCase.pkl b/cp/tests/unitgrade_data/AckermannTestCase.pkl index 07c62368d9f36b3aed6ddb06c1289e94b645b871..301761507ccd40cc6a3288a1808828c8b1d7e0c8 100644 Binary files a/cp/tests/unitgrade_data/AckermannTestCase.pkl and b/cp/tests/unitgrade_data/AckermannTestCase.pkl differ diff --git a/cp/tests/unitgrade_data/Bug.pkl b/cp/tests/unitgrade_data/Bug.pkl index d9c0a0962838a47fb30d7c7e80a1c7076b6ed8d0..3759829f8e12c1292161941718e6c6b75959e463 100644 Binary files a/cp/tests/unitgrade_data/Bug.pkl and b/cp/tests/unitgrade_data/Bug.pkl differ diff --git a/cp/tests/unitgrade_data/Dialogue.pkl b/cp/tests/unitgrade_data/Dialogue.pkl index 444c09c1df1e637bf4e89b097a8ea2e43a393645..50614d7805a30bc523a91f0a63c56f07de3feebe 100644 Binary files a/cp/tests/unitgrade_data/Dialogue.pkl and b/cp/tests/unitgrade_data/Dialogue.pkl differ diff --git a/cp/tests/unitgrade_data/ExponentialTestCase.pkl b/cp/tests/unitgrade_data/ExponentialTestCase.pkl index f4961e3e693f3e092d1eaaa5a39ea06b843a66ff..aa4ca0b11b154439d937a0611798a8e01642ecfb 100644 Binary files a/cp/tests/unitgrade_data/ExponentialTestCase.pkl and b/cp/tests/unitgrade_data/ExponentialTestCase.pkl differ diff --git a/cp/tests/unitgrade_data/Fibonacci.pkl b/cp/tests/unitgrade_data/Fibonacci.pkl index 247013c3c36a73b5209a076c38fa650b1c1b70ee..1a9d7dd9e2298d4d2f79bc70fcc1abe34493e889 100644 Binary files a/cp/tests/unitgrade_data/Fibonacci.pkl and b/cp/tests/unitgrade_data/Fibonacci.pkl differ diff --git a/cp/tests/unitgrade_data/GetAllIntersections.pkl b/cp/tests/unitgrade_data/GetAllIntersections.pkl index adb63277f5e8d3a2547c4076c7730d2a2141c746..90a780a160343daded0d849fc4827362e1550969 100644 Binary files a/cp/tests/unitgrade_data/GetAllIntersections.pkl and b/cp/tests/unitgrade_data/GetAllIntersections.pkl differ diff --git a/cp/tests/unitgrade_data/HeartAttackTests.pkl b/cp/tests/unitgrade_data/HeartAttackTests.pkl index 219cfd8d05c69383a474c70d37069d39658253d1..9d5e20ebcaf436e3daaa3b973883bf62bd3fede0 100644 Binary files a/cp/tests/unitgrade_data/HeartAttackTests.pkl and b/cp/tests/unitgrade_data/HeartAttackTests.pkl differ diff --git a/cp/tests/unitgrade_data/HelloWorld.pkl b/cp/tests/unitgrade_data/HelloWorld.pkl index 2e8657fe04ec1e08addf073f473e493f013103fc..2b8dfdc6cb8b2361b98e3ff37938fbd804e30394 100644 Binary files a/cp/tests/unitgrade_data/HelloWorld.pkl and b/cp/tests/unitgrade_data/HelloWorld.pkl differ diff --git a/cp/tests/unitgrade_data/HelloWorld2.pkl b/cp/tests/unitgrade_data/HelloWorld2.pkl index afa838638f5dedafa4ac7f8d1d40c9f19149c367..217169fca36e529e313c04cc163b410a866fb076 100644 Binary files a/cp/tests/unitgrade_data/HelloWorld2.pkl and b/cp/tests/unitgrade_data/HelloWorld2.pkl differ diff --git a/cp/tests/unitgrade_data/Math.pkl b/cp/tests/unitgrade_data/Math.pkl index d0b77a3789288b05a3d9f875118dbf5158160a9f..1e190ebb28eeefe2462f2a2ff3dde1e828eb987d 100644 Binary files a/cp/tests/unitgrade_data/Math.pkl and b/cp/tests/unitgrade_data/Math.pkl differ diff --git a/cp/tests/unitgrade_data/Palindrome.pkl b/cp/tests/unitgrade_data/Palindrome.pkl index 8368753a860f883d383ee068bddd0a490515d6b3..8be3e64cfb56a0e4519d8b203b33b201295adf61 100644 Binary files a/cp/tests/unitgrade_data/Palindrome.pkl and b/cp/tests/unitgrade_data/Palindrome.pkl differ diff --git a/cp/tests/unitgrade_data/Parenthesis.pkl b/cp/tests/unitgrade_data/Parenthesis.pkl index 3de60d61d5b7c17a0b835fdece98ff6822dec475..c866ce075dcdef8071a75ffce59995075cac0daa 100644 Binary files a/cp/tests/unitgrade_data/Parenthesis.pkl and b/cp/tests/unitgrade_data/Parenthesis.pkl differ diff --git a/cp/tests/unitgrade_data/Prefix.pkl b/cp/tests/unitgrade_data/Prefix.pkl index fe93d9647e7515693bac8f4a38223772456cf3bb..d57be000c9b48b81f3803a4f7c0101baa167685c 100644 Binary files a/cp/tests/unitgrade_data/Prefix.pkl and b/cp/tests/unitgrade_data/Prefix.pkl differ diff --git a/cp/tests/unitgrade_data/SayHelloWorld.pkl b/cp/tests/unitgrade_data/SayHelloWorld.pkl new file mode 100644 index 0000000000000000000000000000000000000000..002e3b6ff28299940a927c486e2d33ebb991ca55 Binary files /dev/null and b/cp/tests/unitgrade_data/SayHelloWorld.pkl differ diff --git a/cp/tests/unitgrade_data/SolarPanelTests.pkl b/cp/tests/unitgrade_data/SolarPanelTests.pkl index cd413fc823aed75523f89ed95485ffe81c37a76e..36ce1a7e706cb81d03ffaaf1e2422660bcdecf0c 100644 Binary files a/cp/tests/unitgrade_data/SolarPanelTests.pkl and b/cp/tests/unitgrade_data/SolarPanelTests.pkl differ diff --git a/cp/tests/unitgrade_data/Taylor.pkl b/cp/tests/unitgrade_data/Taylor.pkl index c82946ab875beadc3a323116bafb4f351b90fd41..5675120a09f75889e06f63448211488af3621927 100644 Binary files a/cp/tests/unitgrade_data/Taylor.pkl and b/cp/tests/unitgrade_data/Taylor.pkl differ diff --git a/cp/tests/unitgrade_data/TaylorVariants.pkl b/cp/tests/unitgrade_data/TaylorVariants.pkl index bf5cc598b2b884615fc0664d7d4be233039c5ed1..f34266daadc6f26d15b258f05a3a6b1146404fa9 100644 Binary files a/cp/tests/unitgrade_data/TaylorVariants.pkl and b/cp/tests/unitgrade_data/TaylorVariants.pkl differ diff --git a/cp/tests/unitgrade_data/TestDoctor.pkl b/cp/tests/unitgrade_data/TestDoctor.pkl index 5ccb099a3c89169646e00df4ffc5d75d077c01bb..2c0be18298d9ceef62ebf476f3874f1c3f1a62c1 100644 Binary files a/cp/tests/unitgrade_data/TestDoctor.pkl and b/cp/tests/unitgrade_data/TestDoctor.pkl differ diff --git a/cp/tests/unitgrade_data/TestIntersection.pkl b/cp/tests/unitgrade_data/TestIntersection.pkl index 7a85fe4c7dd9f2484c00d8542645f8748c93c1c3..655d5de81fe02efc9f2ea316dd6931751d342263 100644 Binary files a/cp/tests/unitgrade_data/TestIntersection.pkl and b/cp/tests/unitgrade_data/TestIntersection.pkl differ diff --git a/cp/tests/unitgrade_data/TestLineSegmentMethods.pkl b/cp/tests/unitgrade_data/TestLineSegmentMethods.pkl index 249e08cef29b5194b0d5da33e962e1019b302105..753250ae299b49b310439e0a0710b6ecd48c6843 100644 Binary files a/cp/tests/unitgrade_data/TestLineSegmentMethods.pkl and b/cp/tests/unitgrade_data/TestLineSegmentMethods.pkl differ diff --git a/cp/tests/unitgrade_data/TestMakeARectangle.pkl b/cp/tests/unitgrade_data/TestMakeARectangle.pkl index 328599a66cc96a684e5a68d444151f36966c5b8c..417838b5a6c6ded27905993507d51d6ff5d31d41 100644 Binary files a/cp/tests/unitgrade_data/TestMakeARectangle.pkl and b/cp/tests/unitgrade_data/TestMakeARectangle.pkl differ diff --git a/cp/tests/unitgrade_data/TestMakeVector.pkl b/cp/tests/unitgrade_data/TestMakeVector.pkl index 5e4f7c1d590038a16f603b322f33f8bcace0e1b0..e8da3d0ccd98ebe38d4ae023a38fd75f192b3ab0 100644 Binary files a/cp/tests/unitgrade_data/TestMakeVector.pkl and b/cp/tests/unitgrade_data/TestMakeVector.pkl differ diff --git a/cp/tests/unitgrade_data/TestPatient.pkl b/cp/tests/unitgrade_data/TestPatient.pkl index 6164cf5941468efba0238df91493f2ef6e2275fc..0a34955d269069207f364601d7592fd9bdeac399 100644 Binary files a/cp/tests/unitgrade_data/TestPatient.pkl and b/cp/tests/unitgrade_data/TestPatient.pkl differ diff --git a/cp/tests/unitgrade_data/TestPerson.pkl b/cp/tests/unitgrade_data/TestPerson.pkl index bf3079f4d6f644af7fa7bf8e4148e5fad91906d3..07e14d5427facc3b51615c4d8b0e862bbbb53652 100644 Binary files a/cp/tests/unitgrade_data/TestPerson.pkl and b/cp/tests/unitgrade_data/TestPerson.pkl differ diff --git a/cp/tests/unitgrade_data/TestRectangleArea.pkl b/cp/tests/unitgrade_data/TestRectangleArea.pkl index a9094be79236ee90dec2ee108b0f6577170b53a9..d6e9f995a1492482ec64a0b417387b2d7724574c 100644 Binary files a/cp/tests/unitgrade_data/TestRectangleArea.pkl and b/cp/tests/unitgrade_data/TestRectangleArea.pkl differ diff --git a/cp/tests/unitgrade_data/TestRectangleInception.pkl b/cp/tests/unitgrade_data/TestRectangleInception.pkl index 4cf5ee7cbd6564ce7761f555384cbab5b110dd75..eed0db12b2074b3dec98c900b261c270d3d09b51 100644 Binary files a/cp/tests/unitgrade_data/TestRectangleInception.pkl and b/cp/tests/unitgrade_data/TestRectangleInception.pkl differ diff --git a/cp/tests/unitgrade_data/TestSplitRectangle.pkl b/cp/tests/unitgrade_data/TestSplitRectangle.pkl index d223dbd45c0888645418950fa600eba0ef20b0a8..9f17158d561339f83967d4cad18371324983100d 100644 Binary files a/cp/tests/unitgrade_data/TestSplitRectangle.pkl and b/cp/tests/unitgrade_data/TestSplitRectangle.pkl differ diff --git a/cp/tests/unitgrade_data/TestVectorOperations.pkl b/cp/tests/unitgrade_data/TestVectorOperations.pkl index 49817e70f8a9a70364d30b69d198240a961d31c1..09b7f0d70526ed821ead5c5d0a50d6b94cd4034c 100644 Binary files a/cp/tests/unitgrade_data/TestVectorOperations.pkl and b/cp/tests/unitgrade_data/TestVectorOperations.pkl differ diff --git a/cp/tests/unitgrade_data/Week03BACCalculator.pkl b/cp/tests/unitgrade_data/Week03BACCalculator.pkl index a628a779a57184b452f5a617c7bd12ad50908bf7..b32216a1aa063534cfb3e04217cd62947f7777ed 100644 Binary files a/cp/tests/unitgrade_data/Week03BACCalculator.pkl and b/cp/tests/unitgrade_data/Week03BACCalculator.pkl differ diff --git a/cp/tests/unitgrade_data/Week03BodyTemperature.pkl b/cp/tests/unitgrade_data/Week03BodyTemperature.pkl index 8105a62a138cfe59c992abdc8f93ab86bb93d8df..0f582c19646bea881fe7974e40d6189dcde2c193 100644 Binary files a/cp/tests/unitgrade_data/Week03BodyTemperature.pkl and b/cp/tests/unitgrade_data/Week03BodyTemperature.pkl differ diff --git a/cp/tests/unitgrade_data/Week03CompareNumbers.pkl b/cp/tests/unitgrade_data/Week03CompareNumbers.pkl index c3832909886a4172b0dd19846ea2b980d9862aa0..379c00fc49bc264461929695c12feb8bae5817f0 100644 Binary files a/cp/tests/unitgrade_data/Week03CompareNumbers.pkl and b/cp/tests/unitgrade_data/Week03CompareNumbers.pkl differ diff --git a/cp/tests/unitgrade_data/Week05Indexing.pkl b/cp/tests/unitgrade_data/Week05Indexing.pkl index 621f2a8d2eea7935a58afa373fefa1609b6d5ee0..c6255dd04b94752ef8f244cc09984a2397e53e8f 100644 Binary files a/cp/tests/unitgrade_data/Week05Indexing.pkl and b/cp/tests/unitgrade_data/Week05Indexing.pkl differ diff --git a/cp/tests/unitgrade_data/Week05Primes.pkl b/cp/tests/unitgrade_data/Week05Primes.pkl index 06246ec0a2c3aa5546cff30ce8b3df904ad7a7a8..3b4e33f2c66fed469d8c3a3721f077413ebc173f 100644 Binary files a/cp/tests/unitgrade_data/Week05Primes.pkl and b/cp/tests/unitgrade_data/Week05Primes.pkl differ diff --git a/cp/tests/unitgrade_data/Week05UpdatingLists.pkl b/cp/tests/unitgrade_data/Week05UpdatingLists.pkl index 58cc6e18188705487d6ae879a78e52c70853e1b3..7d69082c33c3787f723f781849aa33d063d864b4 100644 Binary files a/cp/tests/unitgrade_data/Week05UpdatingLists.pkl and b/cp/tests/unitgrade_data/Week05UpdatingLists.pkl differ diff --git a/cp/tests/unitgrade_data/Week11BMICalc.pkl b/cp/tests/unitgrade_data/Week11BMICalc.pkl index 63c2dc56172606a131349096afde20de60731556..9748adbe05b852ca77c4cff9ea9617699fb0460d 100644 Binary files a/cp/tests/unitgrade_data/Week11BMICalc.pkl and b/cp/tests/unitgrade_data/Week11BMICalc.pkl differ diff --git a/cp/tests/unitgrade_data/Week11DotProducta.pkl b/cp/tests/unitgrade_data/Week11DotProducta.pkl index eb704ad1b36bb81eece8ee74848338cd49a288a0..c3b8c14b899dede84946142f4a3d1e1cde4f73dc 100644 Binary files a/cp/tests/unitgrade_data/Week11DotProducta.pkl and b/cp/tests/unitgrade_data/Week11DotProducta.pkl differ diff --git a/cp/tests/unitgrade_data/Week11DotProductb.pkl b/cp/tests/unitgrade_data/Week11DotProductb.pkl index f195c1a9c86ace10a16ad89e90d25e92991b57d5..03f3c6dfa0ab2a3074ccdcc7c6c56275cf1b70e9 100644 Binary files a/cp/tests/unitgrade_data/Week11DotProductb.pkl and b/cp/tests/unitgrade_data/Week11DotProductb.pkl differ diff --git a/cp/tests/unitgrade_data/Week11StableMeasurements.pkl b/cp/tests/unitgrade_data/Week11StableMeasurements.pkl index 46a86f47e505a7c22650a537b8bf5127cecae3db..65964e9d421250a786d60c60d59796fb1b71cbae 100644 Binary files a/cp/tests/unitgrade_data/Week11StableMeasurements.pkl and b/cp/tests/unitgrade_data/Week11StableMeasurements.pkl differ