For any Assignment related queries, Call us at : -  

+1 678 648 4277

You can mail us at :- support@pythonhomeworkhelp.com or
reach us at :- https://www.pythonhomeworkhelp.com/

Python Homework Help

1 OOP
The following definitions have been entered into a Python shell:
class A:
yours = 0
def __init__(self, inp):
self.yours = inp
def give(self, amt):
self.yours = self.yours + amt
return self.yours
def howmuch(self):
return (A.yours, self.yours)
class B(A):
yours = 0
def give(self, amt):
B.yours = B.yours + amt
return A.howmuch(self)
def take(self, amt):
self.yours = self.yours - amt
return self.yours
def howmuch(self):
return (B.yours, A.yours, self.yours)
Write the values of the following expressions. Write None when
there is no value; write Error when an error results and explain
briefly why it’s an error. Assume that these expressions are
evaluated one after another (all of the left column first, then right
column).

test = A(5) test = B(5)

None
None

test.take(2) test.take(2)
Error
3

test.give(6) test.give(6)
11
(0, 3)

test.howmuch() test.howmuch()

(0, 11) (6, 0, 3)

2 The Best and the Brightest

Here are some class definitions, meant to represent a collection

of students making up the student body of a prestigious
university

class Student:
def __init__(self, name, iq,
salary, height):
self.name = name
self.iq = iq
self.salary = salary
self.height = height

class StudentBody:
def __init__(self):
self.students = []
def addStudent(self, student):

self.students.append(student)
def nameOfSmartest(self):
# code will go here
def funOfBest(self, fun, feature):
# code will go here
The StudentBody class is missing the code for two
methods:
• nameOfSmartest: returns the name attribute of the student with
the highest IQ

• funOfBest: takes a procedure fun and a procedure feature as

input, and returns the result of applying procedure fun to the
student for whom the procedure feature yields the highest value

For the first two problems below, assume that these methods have
been implemented.
Here is a student body:

jody = Student(’Jody’, 100,

100000, 80)
chris = Student(’Chris’, 150,
40000, 62)
dana = Student(’Dana’, 120, 2000,
70) aardvarkU = StudentBody()
aardvarkU.addStudent(jody)
aardvarkU.addStudent(chris)
aardvarkU.addStudent(dana)

pythonhomeworkhelp.com
 1. What is the result of evaluating
aardvarkU.nameOfSmartest()?

’Chris’

2. Write a Python expression that will compute the name of the

person who has the greatest value of IQ + height in aardvarkU
(not just for the example student body above). You can define
additional procedures if you need them.

aardvarkU.funOfBest(lambda x: x.name, lambda x: x.iq +

x.height)

3. Implement the nameOfSmartest method. For full credit, use

util.argmax (defined below) or the funOfBest method.
If l is a list of items and f is a procedure that maps an item into a
numeric score, then util.argmax(l, f) returns the element of l that
has the highest score.

def nameOfSmartest(self):
return util.argmax(self.students,
lambda x: x.iq).name

# or

def nameOfSmartest(self):
return funOfBest(lambda x: x.name,
lambda x: x.iq)

4. Implement the funOfBest method. For full credit, use

util.argmax.
 def funOfBest(self, fun, feature):
return fun(util.argmax(self.students,
feature))

Repeated from the start of the problem:

class Student:
def __init__(self, name, iq, salary,
height):
self.name = name
self.iq = iq
self.salary = salary
self.height = height

class StudentBody:
def __init__(self):
self.students = []
def addStudent(self,
student):
 self.student.append(student)
def deleteStudent(self, student):

self.students.remove(student)
def nameOfSmartest(self):
pass def funOfBest(self, fun,
feature):
pass

Here is a student body:

jody = Student(’Jody’, 100,

100000, 80)
chris = Student(’Chris’, 150,
40000, 62)
dana = Student(’Dana’, 120, 2000,
70) aardvarkU = StudentBody()
aardvarkU.addStudent(jody)
aardvarkU.addStudent(chris)
aardvarkU.addStudent(dana)

3 SM to DE

Here is the definition of a class of state machines:

 class Thing(SM):
startState = [0, 0, 0, 0]
def getNextValues(self, state, inp):
result = state[0] * 2 + state[2]
*3
newState = [state[1], result,
state[3], inp] return (newState,
result)

1. What is the result of evaluating

Thing().transduce([1, 2, 0, 1, 3])

[0, 0, 3, 6, 6]

2. The state machine above describes the behavior of an LTI

system starting at rest. Write a difference equation that
describes the same system as the state machine.
 y[n] = 2 * y[n-2] + 3 * x[n - 2]

4 Diagnosis

What, if anything, is wrong with each of the following state

machine definitions? The syntax is correct (that is, they are all legal
Python programs), so that is not a problem. Write a phrase or a
single sentence if something is wrong or “nothing” if nothing is
wrong
1.

class M1(SM):
startState = 0
def getNextValues(self,
state, inp):
return inp + state
 Should return tuple of new state and output

2.
class M2(SM):
startState = 0
def getNextValues(self,
state, inp):
return (inp+state, (state,
state))

This is fine

3.

class M3(SM):
def __init__(self):
self.startState = [1, 2, 3]
 def getNextValues(self, state, inp):
state.append(inp)
result = sum(state) /
float(len(state))
return (result, state

This modifies the state argument, by doing state.append(inp)

4.

class M4(SM):
startState = -1
def __init__(self, v):
self.value = v
def
getNextValues(self, state, inp):
 if state > inp:
self.value = self.value +
state
result = self.value * 2
return (state, result)

This modifies the attribute value in getNextValues.

5 Picture to Machine

Use sm.Gain, sm.Delay, sm.FeedbackAdd,

sm.FeedbackSubtract, and sm.Cascade to make a state machine
that is equivalent to the following system:
Assume that the system starts at rest, that is, all the signals are
zero at time zero. Assume also that the variables k1 and k2 are
already defined.

Recall that sm.Gain takes a gain as an argument, sm.Delay takes

an initial output value as an argument and each of sm.Cascade,
sm.FeedbackAdd, and sm.FeedbackSubtract, takes two state
machines as arguments.

Use indentation to highlight the structure of your answer.

FeedbackSubtract(Cascade(Cascade(Gain(k1), R()),
FeedbackSubtract(Gain(k2),
Cascade(R(),R()))),
R())

6 On the Verge

For each difference equation below, say whether, for a unit

sample input signal:
• the output of the system it describes will diverge or not,
• the output of the system it describes (a) will always be
positive, (b) will alternate between positive and negative, or
(c) will have a different pattern of oscillation

1.

10y[n] − y[n − 1] = 8x[n − 3]

diverge? Yes or No No

positive/alternate/oscillate Positive

2.

y[n] = −y[n − 1] − 10y[n − 2] + x[n]

diverge? Yes or No Yes

positive/alternate/oscillate Oscillates, pole
is complex

7 What’s Cooking?

Sous vide cooking involves cooking food at a very precise, fixed

temperature T (typically, low enough to keep it moist, but high
enough to kill any pathogens). In this problem, we model the
behavior of the heater and water bath used for such cooking. Let
I be the current going into the heater, and c be the proportionality
constant such that Ic is the rate of heat input.

The system is thus described by the following

diagram:

1. a. Give the system function: H = T/I =

 b. Give a difference equation for the system: T[n] =

T[n] = (k1 − k2)T[n − 1] + k1k2T[n − 2] + cI[n]

2. Let the system start at rest (all signals are zero). Suppose I[0]
= 100 and I[n] = 0 for n > 0. Here are plots of T[n] as a function
of n for this system for c = 1 and different values of k1 and k2.
 a. Which of the plots above corresponds to k1 = 0.5
and k2 = 0 ?

Circle all correct answers:

b. Which of the plots above corresponds to a b k1 =

1 and k2 = 0.5 ?
Circle all correct answers:

3. Let k1 = 0.5, k2 = 3, and c = 1. Determine the poles of H, or

none if there are no poles.

Poles at 0.5 and -3

4. Here is the original system:

Circle all of the following systems that are equivalent (for some
setting of the gains in the triangles) to the original system.
System b has the same system function. System e has the same
poles. We required b to be circled, and considered e to be
correct whether circled or not.