Question

1.

In Chapter 4, we developed an algorithm for converting from binary to decimal. You can generalize this algorithm to work for a representation in any base. Instead of using a power of 2, this time you use a power of the base. Also, you use digits greater than 9, such as A . . . F, when they occur.

In convert.py, define a function named repToDecimal that expects two arguments, a string, and an integer. The second argument should be the base. For example, repToDecimal("10", 8) returns 8, whereas repToDecimal("10", 16) returns 16.

• The function should use a lookup table to find the value of any digit. Make sure that this table (it is actually a dictionary) is initialized before the function is defined.

• For its keys, use the 10 decimal digits (all strings) and the letters A . . . F (all uppercase). The value stored with each key should be the integer that the digit represents. (The letter A associates with the integer value 10, and so on.)

• The main loop of the function should convert each digit to uppercase, look up its value in the table, and use this value in the computation.

• Include a main function that tests the conversion function with numbers in several bases.

2.

package Newtor's method for approximating square roots (Case Study: Approximating Square Roots) in a function named newton . This function expects the input number as an argument and returns the estimate of its square root. The script should also include a main function that allows the user to compute square roots of inputs until she presses the enter/return key

An example of the program input and output is shown below:

Answer 1

1.

alpha .0123456789ABCDEFGHĪJKLMNOPORSTUVWXYZ #initializing dictionary as empty 3 val 0 4 5 def repToDecimal(num, base): 6 7 #following loop fills in the value for each digit for i in range(base): val[alpha[i]]-i 9 10 # m here is pow(base, 1) # to avoid raising to power each time # we multiply m with base in every iteration 12 13 rese # iterate string in reverse order so that LSB is read first for i in num -1]: 15 16 17 18 19 20 21 #dictionary val is used to get corresponding value of current digit d - val[i.upper()] res +- d *m m *-base return res 23 def main(): print (repToDecimal('10', 10)) print(repToDecimal('10', 8)) rint(repToDecimal( '10', 2 print(repToDecimal('10*', 16)) 25 26 27 28 29 main()

2.

A little background.

Newton Raphson's method states that if we have a function

f(x) = 0

and we wish to find an x that is as close to the solution as possible

and we have an initial guess xk.

Then x_k+1 = x_k - f(x_k) / f '(x_k) provides a better solution

Doing this in repetition will take us to an approximated solution.

In our case x² = A can be written as x² - A = 0

with f(x) = x² - A

f '(x) = 2x

hence,  x_k+1 = 0.5 * (x_k + A / x_k)

CODE:

#1 cheated a bit by using default arguments in the function definition #Because I wanted to make this a recursive function #But I believe these arguments are important and #User must be allowed to change these values to see how the working changes 2 3 4 def newton(A, it -e, max_iter - 10e, guess 1): 6 #break when done a specific number of iterations #increase maxiter for more precise result if it max iter: 18 return guess newguess = 0.5 * (guess + A / guess) #pass on the updated guess value to next iteration return newton(A, it + 1, max_iter, new_guess) 12 13 15 def main(): 16 17 while True: a-input( "Enter a positive number or enter/return to quit: ") if not a: 19 20 21 return print("The program's estimate is", newton (int (a))) print( "Python's estimate is", int(a)**e.5) 23 main()

RAW CODES:

alpha = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'

#initializing dictionary as empty

val = {}

def repToDecimal(num, base):

#following loop fills in the value for each digit

for i in range(base):

val[alpha[i]] = i

# m here is pow(base, i)

# to avoid raising to power each time

# we multiply m with base in every iteration

m = 1

res = 0

# iterate string in reverse order so that LSB is read first

for i in num[: : -1]:

#dictionary val is used to get corresponding value of current digit

d = val[i.upper()]

res += d * m

m *= base

return res

def main():

print(repToDecimal('10', 10))

print(repToDecimal('10', 8))

print(repToDecimal('10', 2))

print(repToDecimal('10', 16))

main()

2.

#I cheated a bit by using default arguments in the function definition

#Because I wanted to make this a recursive function

#But I believe these arguments are important and

#User must be allowed to change these values to see how the working changes

def newton(A, it = 0, max_iter = 100, guess = 1):

#break when done a specific number of iterations

#increase max_iter for more precise result

if it >= max_iter:

return guess

new_guess = 0.5 * (guess + A / guess)

#pass on the updated guess value to next iteration

return newton(A, it + 1, max_iter, new_guess)

def main():

while True:

a = input("Enter a positive number or enter/return to quit: ")

if not a:

return

print("The program's estimate is", newton(int(a)))

print("Python's estimate is", int(a)**0.5)

main()

Answer 2

1.

def repToDecimal(str,base):
    result = 0
    #initializing a dictionary
    dict={'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9,'A':10,'B':11,'C':12,'D':13,'E':14,'F':15}
    for i in str:
        n = dict[i]
        result = base * result + n
    return result

#calling the method and displaying the result
print(repToDecimal('10',10))
print(repToDecimal('10',8))
print(repToDecimal('10',2))
print(repToDecimal('10',16))