[Solved] CS 3430 Assignment 1- Function Representation and Differentiation

$25

File Name: CS_3430_Assignment_1-_Function_Representation_and_Differentiation.zip
File Size: 612.3 KB

SKU: [Solved] CS 3430 Assignment 1- Function Representation and Differentiation Category: Tag:
5/5 - (1 vote)

Objectives

  1. Function Representation
  2. Function Differentiation
  3. Differentiation Rules
  4. Converting Function Representations to Python Functions
  5. Graphing Functions and Derivatives

Introduction

In this assignment, youll write Python functions that differentiate function representations, convert those representations to real Python functions, and graph them with matplotlib, one of the Python graphing libraries.

Warmup

If youre new to differentiation or your differentiation skills are rusty, I suggest that you start by reviewing the first two lectures and, if necessary, reading the handout, and then taking the derivatives of the functions below. If youre comfortable with differentiation, skip this section and move on.

  1. ; answer: 18x2;
  2. ); answer: ;
  3. ; answer: ;
  4. ; asnwer: 4x3 + 3x2 + 1;
  5. ; answer: 6(2x + 4)2;
  6. ; answer: ;
  7. ; answer: ;
  8. ; answer: ;
  9. ; answer: 2 + 3(x + 2)2;

; answer: .

Variables, Powers, Sums, and Products

Recall that in lectures 1 and 2 we discussed how such mathematical objects as variables, powers, sums, and products can be represented with Python objects.

The files const.py, var.py, pwr.py, plus.py, prod.py contain classes for constants, variables, powers, sums, and products, respectively. The file maker.py contains several functions for constructing objects of these classes. You dont need to modify these files for this assignment. Lets play with mathematical object construction a little in the Python interpreter window to get more comfortable with them.

Heres how we can construct a constant and get its value.

>>> c1 = make_const(1.0)

>>> c1.get_val()

1.0

>>> c2 = const(val=10.0)

>>> c2.get_val()

10.0

Once we have an object, we can use the function isinstance to check if the object is an instance of a given class. The two calls below show us that c1 is an instance of the class const but not of the class var or the class prod.

>>> isinstance(c1, const)

True

>>> isinstance(c1, var)

False

>>> isinstance(c1, prod)

False

Heres how we can construct a list of constant objects and then extract their values into a new list.

>>> clist = [make_const(i) for i in range(10)]

>>> clist

>>> vlist = [c.get_val() for c in clist]

>>> vlist

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Lets represent the function x2. This power expression has a base of x and a degree of 2. The base is an instance of the class var and the degree is an instance of the class const.

>>> fex = make_pwr(x, 2.0)

>>> b = fex.get_base()

>>> d = fex.get_deg() >>> print b x >>> print d

2.0

>>> isinstance(b, var)

True

>>> isinstance(d, const) True

Finally, lets represent 5x2 + 10x 100.

>>> fex1 = plus(elt1=prod(mult1=make_const(5.0), mult2=make_pwr(x, 2.0)),

elt2=prod(mult1=make_const(10.0), mult2=make_pwr(x, 1.0)))

>>> fex2 = plus(elt1=fex1, elt2=make_const(-100.0))

>>> fex2 = plus(elt1=fex1, elt2=make_const(-100.0))

>>> print fex2

(((5.0*(x^2.0))+(10.0*(x^1.0)))+-100.0)

Lets represent 5x2. The products first multiple is 5 and its second multiple is x2.

>>> fex = prod(mult1=make_const(5.0), mult2=make_pwr(x, 2.0))

>>> print fex

(5.0*(x^2.0))

>>> print fex.get_mult1() 5.0

>>> print fex.get_mult2()

(x^2.0)

Problem 1: (3 points)

Implement the function deriv that takes a function representation and computes a representation of its derivative. Your implemenation should be able to handle constants, powers, products, and sums. For this assignment, you should handle only simple products and simple powers. Well handle more complex products, powers, and quotients later in the course.

A simple product can be recursively defined as a product of two constants, a constant and a simple power, a constant and a plus, and a constant and another simple product.

A simple power expression is recursively defined as an expression whose degree is a constant and whose base is a variable, a simple power, a sum, and a simple product. Below are a few test cases of how your implementation of deriv should work.

Lets start with x1.

>>> fex = make_pwr(x, 1.0)

>>> print fex

(x^1.0)

>>> drv = deriv(fex)

>>> print drv

(1.0*(x^0.0))

Lets compute the derivative of another power.

>>> fex = make_pwr(z, 5)

>>> print fex

(z^5)

>>> drv = deriv(fex)

>>> print drv (5*(z^4.0))

One more power expression, slightly more complex than the one above.

>>> fex = make_pwr_expr(make_pwr(x, 2.0), 2.0)

>>> print fex

((x^2.0)^2.0)

>>> drv = deriv(fex)

>>> print drv

((2.0*((x^2.0)^1.0))*(2.0*(x^1.0)))

Lets represent and differentiate 5x2 and x25. Note that both expressions differentiate to the same expression.

>>> fex = prod(mult1=make_const(5.0), mult2=make_pwr(x, 2.0))

>>> drv = deriv(fex)

>>> print drv

(5.0*(2.0*(x^1.0)))

>>> fex = prod(mult1=make_pwr(x, 2.0), mult2=make_const(5.0))

>>> print fex

((x^2.0)*5.0)

>>> drv = deriv(fex)

>>> print drv

(5.0*(2.0*(x^1.0)))

Lets differentiate (5x10)4 using the power rule.

>>> prd = prod(mult1=make_const(5.0), mult2=make_pwr(x, 10.0))

>>> fex = make_pwr_expr(prd, 4.0)

>>> print fex

((5.0*(x^10.0))^4.0)

>>> drv = deriv(fex)

>>> print drv

((4.0*((5.0*(x^10.0))^3.0))*(5.0*(10.0*(x^9.0))))

Here is another application of the power rule to differentiate (x3 + 3)4.

>>> fex = make_pwr_expr(plus(elt1=make_pwr(x, 3.0),

elt2=make_const(3.0)), 4.0)

>>> print fex

(((x^3.0)+3.0)^4.0)

>>> drv = deriv(fex)

>>> print drv

((4.0*(((x^3.0)+3.0)^3.0))*((3.0*(x^2.0))+0.0))

Lets differentiate a simple polynomial x2 + x 100.

>>> fex = plus(elt1=make_pwr(x, 2.0), elt2=make_pwr(x, 1.0))

>>> fex2 = plus(elt1=fex, elt2=make_const(-100.0))

>>> print fex2

(((x^2.0)+(x^1.0))+-100.0)

>>> drv = deriv(fex2)

>>> print drv

(((2.0*(x^1.0))+(1.0*(x^0.0)))+0.0)

There is some starter code for you in deriv.py. Write your code for Problem 1 in there.

Problem 2: (1 points)

Function representations are really useful but if we want to do scientific computing with them, we must be able to convert them into real Python functions. Write a function tof (this abbreviation stands for to function) that takes a function expression (see Problem 1) and returns a Python function that actually computes the function represented by this expression. Here is a few test runs.

Lets work with x2 + x 100.

>>> fex = plus(elt1=make_pwr(x, 2.0), elt2=make_pwr(x, 1.0))

>>> fex2 = plus(elt1=fex, elt2=make_const(-100.0))

>>> print fex2

(((x^2.0)+(x^1.0))+-100.0)

Lets define a Python function that computes this polynomial.

>>> f = lambda x: x**2.0 + x 100.0

>>> f

<function <lambda> at 0x7fcf2bf40050>

Lets run tof on fex2 and save the function returned by tof in the variable tf. We also define a test function and test f and tf on [0,999].

>>> tf = tof(fex2)

>>> tf

<function f at 0x7fcf2bf400c8> >>> def test():

for i in range(1000):

assert f(i) == tf(i)

print test passed >>> test() test passed

Lets do another test with 5x2.

>>> fex = prod(mult1=make_const(5.0), mult2=make_pwr(x, 2.0))

>>> print fex

(5.0*(x^2.0))

>>> f = lambda x: 5.0*(x**2.0)

>>> tf = tof(fex) >>> def test():

for i in range(1000):

assert f(i) == tf(i)

print test passed

>>> test() test passed

There is some starter code for you in tof.py. Write your code for Problem 2 in there.

Problem 3: (1 points)

Lets finish it off by writing a function graph_drv that takes an function expression, differentiates it, converts both the function expression and the derivative expression into functions with tof and graphs both functions in the same plot. The function also takes a two-element list of floats, xlim, and another two element list of floats, ylim. These two lists specify the lower and upper bounds for the x-axis and y-axis, respectively, for the plots grid. You should study the plotting code segments from the first two lectures (e.g., lec01_01.py and lect02_03.py) on how to use xlim and ylim.

Here is an example of applying graph_drv to the representation of 2x5. The plot of the function and its derivative for this test is shown in Fig. 1.

>>> prd = prod(mult1=make_const(2.0), mult2=make_pwr(x, 5.0))

>>> graph_drv(prd, [-3.0, 3.0], [-50.0, 50.0])

Lets apply graph_drv to the representation of x4 + x3 + x. The plot of the function and its derivative for this test is shown in Fig. 2.

>>> fex1 = make_pwr(x, 4.0)

>>> fex2 = make_pwr(x, 3.0)

>>> fex3 = make_pwr(x, 1.0)

>>> fex4 = plus(elt1=fex1, elt2=fex2)

>>> fex5 = plus(elt1=fex4, elt2=fex3)

>>> graph_drv(fex5, [-2.5, 2.5], [-10.0, 10.0])

There is some starter code for you in graphdrv.py. Write your code for Problem 3 in there.

Figure 1: Plots of 2x5 and 10x4.

Figure 2: Plots of x4 + x3 + x and 4x3 + 3x2 + 1.

Reviews

There are no reviews yet.

Only logged in customers who have purchased this product may leave a review.

Shopping Cart
[Solved] CS 3430 Assignment 1- Function Representation and Differentiation
$25