Question

need help with this python program

NOTE: You are NOT permitted to use ANY global variables. The use of any global variables will result in a deduction of 20%.

NOTE: There is NO input or printing anywhere other than main! Significant points will be deducted if you violate this constraint!

The following UML diagrams specify three classes. The RC_Filter class has a composition relationship with the Resistor and Capacitor classes. Your job is to implement these three classes as specified below. None of these three classes do ANY input or printing operations. You can NOT add any other members to these three classes.

Resistor

- resistance: float - tolerance: float

+ __init__(float, float) : + get_resistance( ) : float + set_resistance(float) + get_tolerance( ) : float + set_tolerance(float) + getMin( ) : float + getMax( ) : float + __repr__( ) : string

Capacitor

- capacitance: float - tolerance: float

+ __init__(float, float): + get_ capacitance ( ) : float + set_ capacitance (float) + get_tolerance( ) : float + set_tolerance(float) + getMin( ) : float + getMax( ) : float + __repr__( ) : string

The __init__ methods of these two classes set the values of the resistance, capacitance, and tolerance according to the parameter values. The getMin methods return the value of the resistance or capacitance minus the tolerance amount. The tolerance is a percentage (ie. 5%), so the minimum is nominal * (1 – tolerance/100). The getMax methods work like the getMin methods except they return the maximum resistance or capacitance which is nominal * (1 + tolerance/100). The __repr__ method returns a formatted string containing the resistance and the tolerance values.

Note: the resistance, capacitance, and tolerance must be setup as properties with methods to set and get the property values. The set methods should raise a ValueError exception if the argument value is <= 0.

RC_Filter

+ resistor: Resistor + capacitor: Capacitor

+ __init__(Resistor, Capacitor) : + getNominalCutoff( ) : float + getMinCutoff( ) : float + getMaxCutoff( ) : float + __repr__( ) : string

The RC_Filter class __init__ method has the following parameters: a Resistor object and a Capacitor object. These are stored as the member variables of the class. The getNominalCutoff method returns the filter’s cutoff frequency using the nominal resistance and capacitance values. The formula for calculating cutoff frequency is:

1 / (2 * pi * resistance * capacitance)

The getMinCutoff method returns the minimum cutoff frequency which is calculated using the maximum resistance and capacitance values. The getMaxCutoff method returns the maximum cutoff frequency which is calculated using the minimum resistance and capacitance values. The __repr__ method returns a string containing the resistance and capacitance information.

The main function will ask the user to enter values for resistance, tolerance, and capacitance, tolerance. It will create Resistor and Capacitor objects, and an RC_Filter object. It will call the methods on the filter object to verify that the methods of all three classes are working correctly.

The following is sample output from running the program.

Enter the resistance value: 1000

Enter the resistor tolerance: 10

Enter the capacitance value: .000001

Enter the capacitor tolerance: 10

Resistance: 1000.0 ohms

Tolerance: 10.0%

Capacitance: 0.000001 farads

Tolerance: 10.0%

Nominal Cutoff Frequency is 159.15 Hz

Minimum Cutoff Frequency is 131.53 Hz

Maximum Cutoff Frequency is 196.49 Hz

Answer 1

Solution:

import math


class Resistor:
    _resistance = 0.0
    _tolerance = 0.0

    def __init__(self, r, t):
        self._resistance = r
        self._tolerance = t

    def get_resistance(self):
        return self._resistance

    def set_resistance(self, r):
        if r <= 0:
            raise ValueError
        self._resistance = r

    def get_tolerance(self):
        return self._tolerance

    def set_tolerance(self, t):
        if t <= 0:
            raise ValueError
        self._tolerance = t

    def getMin(self):
        return (self._resistance) * (1 - (self._tolerance / 100))

    def getMax(self):
        return (self._resistance) * (1 + (self._tolerance / 100))

    def __repr__(self):
        return "Resistance:" + str(self._resistance) + " ohms\n" + "Tolerance:" + str(self._tolerance) + "%"


class Capacitor:
    _capacitance = 0.0
    _tolerance = 0.0

    def __init__(self, c, t):
        self._capacitance = c
        self._tolerance = t

    def get_capacitance(self):
        return self._capacitance

    def set_capacitance(self, c):
        if c <= 0:
            raise ValueError
        self._capacitance = c

    def get_tolerance(self):
        return self._tolerance

    def set_tolerance(self, t):
        if t <= 0:
            raise ValueError
        self._tolerance = t

    def getMin(self):
        return (self._capacitance) * (1 - (self._tolerance / 100))

    def getMax(self):
        return (self._capacitance) * (1 + (self._tolerance / 100))

    def __repr__(self):
        return "Capacitance:" + str(format(self._capacitance, '.6f')) + " farads\n" + "Tolerance:" + str(
            self._tolerance) + "%"


class RC_Filter:
    def __init__(self, r, c):
        self._resistor = r
        self._capacitor = c

    def getNominalCutoff(self):
        return 1 / (2 * math.pi * self._resistor.get_resistance() * self._capacitor.get_capacitance())

    def getMinCutoff(self):
        return 1 / (2 * math.pi * self._resistor.getMax() * self._capacitor.getMax())

    def getMaxCutoff(self):
        return 1 / (2 * math.pi * self._resistor.getMin() * self._capacitor.getMin())

    def __repr__(self):
        return "Nominal Cutoff Frequency is " + str(
            round(self.getNominalCutoff(), 2)) + " Hz\n" + "Minimum Cutoff Frequency is " + str(
            round(self.getMinCutoff(), 2)) + " Hz\n" + "Maximum Cutoff Frequency is " + str(
            round(self.getMaxCutoff(), 2)) + " Hz"


r = float(input('Enter the resistance value:'))
t = float(input('Enter the resistor tolerance:'))
R = Resistor(r, t)
c = float(input('Enter the capacitance value:'))
t = float(input('Enter the capacitor tolerance:'))
C = Capacitor(c, t)
print(R.__repr__())
print(C.__repr__())
RC = RC_Filter(R, C)
print(RC.__repr__())

Output: