程序代写代做代考 algorithm python CSC338. Homework 1¶

CSC338. Homework 1¶
Due Date: Wednesday January 15, 9pm
Please see the guidelines at https://www.cs.toronto.edu/~lczhang/338/homework.html
What to Hand In¶
Please hand in 2 files:
• Python File containing all your code, named hw1.py.
• PDF file named hw1_written.pdf containing your solutions to the written parts of the assignment. Your solution can be hand-written, but must be legible. Graders may deduct marks for illegible or poorly presented solutions.
If you are using Jupyter Notebook to complete the work, your notebook can be exported as a .py file (File -> Download As -> Python). Your code will be auto-graded using Python 3.6, so please make sure that your code runs. There will be a 20% penalty if you need a remark due to small issues that renders your code untestable.
Make sure to remove or comment out all matplotlib or other expensive code before submitting your code!
Submit the assignment on MarkUs by 9pm on the due date. See the syllabus for the course policy regarding late assignments. All assignments must be done individually.
In [17]:
import math
import numpy as np

Question 1.¶
For parts (a) and (b), consider the problem of evaluating the function $g(x) = x^2 + x – 4$. Suppose there is a small error, $h$ in the value of $x$.
Part (a) — 6pt¶
What is the absolute error and relative error in computing $g(x)$? Implement function and g_abs_err(x, h) and g_rel_err(x, h) to compute those quantities.
In [ ]:
def g_abs_err(x, h):
“””Returns the absolute error of computing `g` at `x` if `x` is
perturbed by a small value `h`.
“””
return None

def g_rel_err(x, h):
“””Returns the relative error of computing `g` at `x` if `x` is
perturbed by a small value `h`.
“””
return None

Part (b) — 3pt¶
Estimate the condition number for the problem. Simplify this answer. For what values of $x$ is this problem well-conditioned? Include your solution in your PDF file.
Part (c) — 2pt¶
For parts (c) and (d), consider the problem of finding a root of the function $g(x) = x^2 + x + c$ by using the Quadratic Formula and taking the positive squareroot. Suppose there is a small error, $h$ in the value of $c$.
For what values of $c$ is this problem well-posed? Include your solution in your PDF file.
Part (d) — 6pt¶
What is the absolute error and relative error in computing $g(x)$? Implement function and g_root_abs_err(c, h) and g_root_rel_err(c, h) to compute those quantities.
In [ ]:
def g_root_abs_err(c, h):
“””Returns the absolute error of finding the (most) positive root of `g` when
`c` is perturbed by a small value `h`.
“””
return None

def g_root_rel_err(c, h):
“””Returns the relative error of finding the (most) positive root of `g` when
`c` is perturbed by a small value `h`.
“””
return None

Question 2.¶
Consider the function, which is also implemented below. You can run the plot_f python function to see what the graph of $f$ looks like.
$f(x) = \frac{x – sin(x)}{x^3}$
In [44]:
def f(x):
return x*x*x + 5 * x*x – 3* x + 5

def plot_f():
import matplotlib.pyplot as plt
xs = [x for x in np.arange(-3.0, 3.0, 0.01)]
ys = [f(x) for x in xs]
plt.plot(xs, ys, ‘bo’)
plt.plot(-2, f(-2), ‘or’, markersize=12)
plt.plot(-0.5, f(-0.5), ‘og’, markersize=12)

plot_f() # please comment this out before submitting, or your code might be untestable


In [39]:
import matplotlib.pyplot as plt
help(plt.plot)

Help on function plot in module matplotlib.pyplot:

plot(*args, scalex=True, scaley=True, data=None, **kwargs)
Plot y versus x as lines and/or markers.

Call signatures::

plot([x], y, [fmt], data=None, **kwargs)
plot([x], y, [fmt], [x2], y2, [fmt2], …, **kwargs)

The coordinates of the points or line nodes are given by *x*, *y*.

The optional parameter *fmt* is a convenient way for defining basic
formatting like color, marker and linestyle. It’s a shortcut string
notation described in the *Notes* section below.

>>> plot(x, y) # plot x and y using default line style and color
>>> plot(x, y, ‘bo’) # plot x and y using blue circle markers
>>> plot(y) # plot y using x as index array 0..N-1
>>> plot(y, ‘r+’) # ditto, but with red plusses

You can use `.Line2D` properties as keyword arguments for more
control on the appearance. Line properties and *fmt* can be mixed.
The following two calls yield identical results:

>>> plot(x, y, ‘go–‘, linewidth=2, markersize=12)
>>> plot(x, y, color=’green’, marker=’o’, linestyle=’dashed’,
… linewidth=2, markersize=12)

When conflicting with *fmt*, keyword arguments take precedence.

**Plotting labelled data**

There’s a convenient way for plotting objects with labelled data (i.e.
data that can be accessed by index “obj[‘y’]“). Instead of giving
the data in *x* and *y*, you can provide the object in the *data*
parameter and just give the labels for *x* and *y*::

>>> plot(‘xlabel’, ‘ylabel’, data=obj)

All indexable objects are supported. This could e.g. be a `dict`, a
`pandas.DataFame` or a structured numpy array.

**Plotting multiple sets of data**

There are various ways to plot multiple sets of data.

– The most straight forward way is just to call `plot` multiple times.
Example:

>>> plot(x1, y1, ‘bo’)
>>> plot(x2, y2, ‘go’)

– Alternatively, if your data is already a 2d array, you can pass it
directly to *x*, *y*. A separate data set will be drawn for every
column.

Example: an array “a“ where the first column represents the *x*
values and the other columns are the *y* columns::

>>> plot(a[0], a[1:])

– The third way is to specify multiple sets of *[x]*, *y*, *[fmt]*
groups::

>>> plot(x1, y1, ‘g^’, x2, y2, ‘g-‘)

In this case, any additional keyword argument applies to all
datasets. Also this syntax cannot be combined with the *data*
parameter.

By default, each line is assigned a different style specified by a
‘style cycle’. The *fmt* and line property parameters are only
necessary if you want explicit deviations from these defaults.
Alternatively, you can also change the style cycle using the
‘axes.prop_cycle’ rcParam.

Parameters
———-
x, y : array-like or scalar
The horizontal / vertical coordinates of the data points.
*x* values are optional. If not given, they default to
“[0, …, N-1]“.

Commonly, these parameters are arrays of length N. However,
scalars are supported as well (equivalent to an array with
constant value).

The parameters can also be 2-dimensional. Then, the columns
represent separate data sets.

fmt : str, optional
A format string, e.g. ‘ro’ for red circles. See the *Notes*
section for a full description of the format strings.

Format strings are just an abbreviation for quickly setting
basic line properties. All of these and more can also be
controlled by keyword arguments.

data : indexable object, optional
An object with labelled data. If given, provide the label names to
plot in *x* and *y*.

.. note::
Technically there’s a slight ambiguity in calls where the
second label is a valid *fmt*. `plot(‘n’, ‘o’, data=obj)`
could be `plt(x, y)` or `plt(y, fmt)`. In such cases,
the former interpretation is chosen, but a warning is issued.
You may suppress the warning by adding an empty format string
`plot(‘n’, ‘o’, ”, data=obj)`.

Other Parameters
—————-
scalex, scaley : bool, optional, default: True
These parameters determined if the view limits are adapted to
the data limits. The values are passed on to `autoscale_view`.

**kwargs : `.Line2D` properties, optional
*kwargs* are used to specify properties like a line label (for
auto legends), linewidth, antialiasing, marker face color.
Example::

>>> plot([1,2,3], [1,2,3], ‘go-‘, label=’line 1’, linewidth=2)
>>> plot([1,2,3], [1,4,9], ‘rs’, label=’line 2′)

If you make multiple lines with one plot command, the kwargs
apply to all those lines.

Here is a list of available `.Line2D` properties:

agg_filter: a filter function, which takes a (m, n, 3) float array and a dpi value, and returns a (m, n, 3) array
alpha: float
animated: bool
antialiased: bool
clip_box: `.Bbox`
clip_on: bool
clip_path: [(`~matplotlib.path.Path`, `.Transform`) | `.Patch` | None]
color: color
contains: callable
dash_capstyle: {‘butt’, ’round’, ‘projecting’}
dash_joinstyle: {‘miter’, ’round’, ‘bevel’}
dashes: sequence of floats (on/off ink in points) or (None, None)
drawstyle: {‘default’, ‘steps’, ‘steps-pre’, ‘steps-mid’, ‘steps-post’}
figure: `.Figure`
fillstyle: {‘full’, ‘left’, ‘right’, ‘bottom’, ‘top’, ‘none’}
gid: str
in_layout: bool
label: object
linestyle: {‘-‘, ‘–‘, ‘-.’, ‘:’, ”, (offset, on-off-seq), …}
linewidth: float
marker: unknown
markeredgecolor: color
markeredgewidth: float
markerfacecolor: color
markerfacecoloralt: color
markersize: float
markevery: unknown
path_effects: `.AbstractPathEffect`
picker: float or callable[[Artist, Event], Tuple[bool, dict]]
pickradius: float
rasterized: bool or None
sketch_params: (scale: float, length: float, randomness: float)
snap: bool or None
solid_capstyle: {‘butt’, ’round’, ‘projecting’}
solid_joinstyle: {‘miter’, ’round’, ‘bevel’}
transform: matplotlib.transforms.Transform
url: str
visible: bool
xdata: 1D array
ydata: 1D array
zorder: float

Returns
——-
lines
A list of `.Line2D` objects representing the plotted data.

See Also
——–
scatter : XY scatter plot with markers of varying size and/or color (
sometimes also called bubble chart).

Notes
—–
**Format Strings**

A format string consists of a part for color, marker and line::

fmt = ‘[color][marker][line]’

Each of them is optional. If not provided, the value from the style
cycle is used. Exception: If “line“ is given, but no “marker“,
the data will be a line without markers.

**Colors**

The following color abbreviations are supported:

============= ===============================
character color
============= ===============================
“’b’“ blue
“’g’“ green
“’r’“ red
“’c’“ cyan
“’m’“ magenta
“’y’“ yellow
“’k’“ black
“’w’“ white
============= ===============================

If the color is the only part of the format string, you can
additionally use any `matplotlib.colors` spec, e.g. full names
(“’green’“) or hex strings (“’#008000’“).

**Markers**

============= ===============================
character description
============= ===============================
“’.’“ point marker
“’,’“ pixel marker
“’o’“ circle marker
“’v’“ triangle_down marker
“’^’“ triangle_up marker
“’<'`` triangle_left marker ``'>‘“ triangle_right marker
“’1’“ tri_down marker
“’2’“ tri_up marker
“’3’“ tri_left marker
“’4’“ tri_right marker
“’s’“ square marker
“’p’“ pentagon marker
“’*’“ star marker
“’h’“ hexagon1 marker
“’H’“ hexagon2 marker
“’+’“ plus marker
“’x’“ x marker
“’D’“ diamond marker
“’d’“ thin_diamond marker
“’|’“ vline marker
“’_’“ hline marker
============= ===============================

**Line Styles**

============= ===============================
character description
============= ===============================
“’-‘“ solid line style
“’–‘“ dashed line style
“’-.’“ dash-dot line style
“’:’“ dotted line style
============= ===============================

Example format strings::

‘b’ # blue markers with default shape
‘ro’ # red circles
‘g-‘ # green solid line
‘–‘ # dashed line with default color
‘k^:’ # black triangle_up markers connected by a dotted line

.. note::
In addition to the above described arguments, this function can take a
**data** keyword argument. If such a **data** argument is given, the
following arguments are replaced by **data[]**:

* All arguments with the following names: ‘x’, ‘y’.

Objects passed as **data** must support item access (“data[]“) and
membership test (“ in data“).

Part (a) — 2pt¶
What is $f(0.00000001)$? Save the results in the variable q2_est.
Given that $f$ is continuous except at $x = 0$, what should $f(0.00000001)$ be? Save the results in the variable q2_true.
In [ ]:
q2_est = None
q2_true = None

Part (b) — 2pt¶
Why does the Python statement compute such inaccurate values of $f(0.00000001)$? Include your answer in your PDF File.
Part (c) — 5pt¶
Define a Python function f2(x) that uses a different algorithm to compute more accurate values of $f(x)$ for $0 < x \le \frac{\pi}{2}$. More specifically, the relative error should be no more than 1% for those values of $x$. In [ ]: def f2(x): return None Question 3. -- 4pt¶ The sine function is given by the infinite series $\sin(x) = x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} + ...$ Compute the absolute forward and backwards error if we approximate the sine function by the first two terms of the series for elements of the array xs below. Save your solution in the array q3_forward and q3_backward, so that q3_forward[i] and q3_backward[i] are the absolute forward and backward errors corresponding to the input xs[i]. You may find the functions math.sin and math.asin helpful. You may assume that the true value of $\sin(x)$ can be computed using the function math.sin. Update (Jan 9th): If the backward error does not exist, please enter "DNE". In [ ]: xs = [0.1, 0.5, 1.0, 3.0] q3_forward = [None, None, None, None] q3_backward = [None, None, None, None] # math.sin(0.2) # math.asin(0.2) # arcsin