def testTF(self, verbose=False):
        """ Directly tests the functions tb04ad and td04ad through direct
            comparison of transfer function coefficients.
            Similar to convert_test, but tests at a lower level.
        """
        from slycot import tb04ad, td04ad
        for states in range(1, self.maxStates):
            for inputs in range(1, self.maxI+1):
                for outputs in range(1, self.maxO+1):
                    for testNum in range(self.numTests):
                        ssOriginal = matlab.rss(states, outputs, inputs)
                        if (verbose):
                            print('====== Original SS ==========')
                            print(ssOriginal)
                            print('states=', states)
                            print('inputs=', inputs)
                            print('outputs=', outputs)

                        tfOriginal_Actrb, tfOriginal_Bctrb, tfOriginal_Cctrb,\
                            tfOrigingal_nctrb, tfOriginal_index,\
                            tfOriginal_dcoeff, tfOriginal_ucoeff =\
                            tb04ad(states, inputs, outputs,
                                   ssOriginal.A, ssOriginal.B,
                                   ssOriginal.C, ssOriginal.D, tol1=0.0)

                        ssTransformed_nr, ssTransformed_A, ssTransformed_B,\
                            ssTransformed_C, ssTransformed_D\
                            = td04ad('R', inputs, outputs, tfOriginal_index,
                                     tfOriginal_dcoeff, tfOriginal_ucoeff,
                                     tol=0.0)

                        tfTransformed_Actrb, tfTransformed_Bctrb,\
                            tfTransformed_Cctrb, tfTransformed_nctrb,\
                            tfTransformed_index, tfTransformed_dcoeff,\
                            tfTransformed_ucoeff = tb04ad(
                                ssTransformed_nr, inputs, outputs,
                                ssTransformed_A, ssTransformed_B,
                                ssTransformed_C, ssTransformed_D, tol1=0.0)
                        # print 'size(Trans_A)=',ssTransformed_A.shape
                        if (verbose):
                            print('===== Transformed SS ==========')
                            print(matlab.ss(ssTransformed_A, ssTransformed_B,
                                            ssTransformed_C, ssTransformed_D))
                            # print 'Trans_nr=',ssTransformed_nr
                            # print 'tfOrig_index=',tfOriginal_index
                            # print 'tfOrig_ucoeff=',tfOriginal_ucoeff
                            # print 'tfOrig_dcoeff=',tfOriginal_dcoeff
                            # print 'tfTrans_index=',tfTransformed_index
                            # print 'tfTrans_ucoeff=',tfTransformed_ucoeff
                            # print 'tfTrans_dcoeff=',tfTransformed_dcoeff
                        # Compare the TF directly, must match
                        # numerators
                        np.testing.assert_array_almost_equal(
                            tfOriginal_ucoeff, tfTransformed_ucoeff, decimal=3)
                        # denominators
                        np.testing.assert_array_almost_equal(
                            tfOriginal_dcoeff, tfTransformed_dcoeff, decimal=3)
Example #2
0
    def testTF(self, verbose=False):
        """ Directly tests the functions tb04ad and td04ad through direct
            comparison of transfer function coefficients.
            Similar to convert_test, but tests at a lower level.
        """
        from slycot import tb04ad, td04ad
        for states in range(1, self.maxStates):
            for inputs in range(1, self.maxI + 1):
                for outputs in range(1, self.maxO + 1):
                    for testNum in range(self.numTests):
                        ssOriginal = matlab.rss(states, outputs, inputs)
                        if (verbose):
                            print('====== Original SS ==========')
                            print(ssOriginal)
                            print('states=', states)
                            print('inputs=', inputs)
                            print('outputs=', outputs)

                        tfOriginal_Actrb, tfOriginal_Bctrb, tfOriginal_Cctrb,\
                            tfOrigingal_nctrb, tfOriginal_index,\
                            tfOriginal_dcoeff, tfOriginal_ucoeff =\
                            tb04ad(states, inputs, outputs,
                                   ssOriginal.A, ssOriginal.B,
                                   ssOriginal.C, ssOriginal.D, tol1=0.0)

                        ssTransformed_nr, ssTransformed_A, ssTransformed_B,\
                            ssTransformed_C, ssTransformed_D\
                            = td04ad('R', inputs, outputs, tfOriginal_index,
                                     tfOriginal_dcoeff, tfOriginal_ucoeff,
                                     tol=0.0)

                        tfTransformed_Actrb, tfTransformed_Bctrb,\
                            tfTransformed_Cctrb, tfTransformed_nctrb,\
                            tfTransformed_index, tfTransformed_dcoeff,\
                            tfTransformed_ucoeff = tb04ad(
                                ssTransformed_nr, inputs, outputs,
                                ssTransformed_A, ssTransformed_B,
                                ssTransformed_C, ssTransformed_D, tol1=0.0)
                        # print('size(Trans_A)=',ssTransformed_A.shape)
                        if (verbose):
                            print('===== Transformed SS ==========')
                            print(
                                matlab.ss(ssTransformed_A, ssTransformed_B,
                                          ssTransformed_C, ssTransformed_D))
    def testTF(self, verbose=False):
        """ Directly tests the functions tb04ad and td04ad through direct comparison of transfer function coefficients.
            Similar to convert_test, but tests at a lower level.
        """
        from slycot import tb04ad, td04ad
        for states in range(1, self.maxStates):
            for inputs in range(1, self.maxI + 1):
                for outputs in range(1, self.maxO + 1):
                    for testNum in range(self.numTests):
                        ssOriginal = matlab.rss(states, outputs, inputs)
                        if (verbose):
                            print('====== Original SS ==========')
                            print(ssOriginal)
                            print('states=', states)
                            print('inputs=', inputs)
                            print('outputs=', outputs)


                        tfOriginal_Actrb, tfOriginal_Bctrb, tfOriginal_Cctrb, tfOrigingal_nctrb, tfOriginal_index,\
                            tfOriginal_dcoeff, tfOriginal_ucoeff = tb04ad(states,inputs,outputs,\
                            ssOriginal.A,ssOriginal.B,ssOriginal.C,ssOriginal.D,tol1=0.0)

                        ssTransformed_nr, ssTransformed_A, ssTransformed_B, ssTransformed_C, ssTransformed_D\
                            = td04ad('R',inputs,outputs,tfOriginal_index,tfOriginal_dcoeff,tfOriginal_ucoeff,tol=0.0)

                        tfTransformed_Actrb, tfTransformed_Bctrb, tfTransformed_Cctrb, tfTransformed_nctrb,\
                            tfTransformed_index, tfTransformed_dcoeff, tfTransformed_ucoeff = tb04ad(ssTransformed_nr,\
                            inputs,outputs,ssTransformed_A, ssTransformed_B, ssTransformed_C,ssTransformed_D,tol1=0.0)
                        #print 'size(Trans_A)=',ssTransformed_A.shape
                        if (verbose):
                            print('===== Transformed SS ==========')
                            print(
                                matlab.ss(ssTransformed_A, ssTransformed_B,
                                          ssTransformed_C, ssTransformed_D))
                            # print 'Trans_nr=',ssTransformed_nr
                            # print 'tfOrig_index=',tfOriginal_index
                            # print 'tfOrig_ucoeff=',tfOriginal_ucoeff
                            # print 'tfOrig_dcoeff=',tfOriginal_dcoeff
                            # print 'tfTrans_index=',tfTransformed_index
                            # print 'tfTrans_ucoeff=',tfTransformed_ucoeff
                            # print 'tfTrans_dcoeff=',tfTransformed_dcoeff
                    #Compare the TF directly, must match
                    #numerators
                        np.testing.assert_array_almost_equal(
                            tfOriginal_ucoeff, tfTransformed_ucoeff, decimal=3)
                        #denominators
                        np.testing.assert_array_almost_equal(
                            tfOriginal_dcoeff, tfTransformed_dcoeff, decimal=3)
    def testFreqResp(self):
        """Compare the bode reponses of the SS systems and TF systems to the original SS
           They generally are different realizations but have same freq resp. 
           Currently this test may only be applied to SISO systems.
        """              
        for states in range(1,self.maxStates):
            for testNum in range(self.numTests):                       
                for inputs in range(1,1):
                    for outputs in range(1,1):       
                        ssOriginal = matlab.rss(states, inputs, outputs)
                        
                        tfOriginal_Actrb, tfOriginal_Bctrb, tfOriginal_Cctrb, tfOrigingal_nctrb, tfOriginal_index,\
                            tfOriginal_dcoeff, tfOriginal_ucoeff = tb04ad(states,inputs,outputs,\
                            ssOriginal.A,ssOriginal.B,ssOriginal.C,ssOriginal.D,tol1=0.0)
                        
                        ssTransformed_nr, ssTransformed_A, ssTransformed_B, ssTransformed_C, ssTransformed_D\
                            = td04ad('R',inputs,outputs,tfOriginal_index,tfOriginal_dcoeff,tfOriginal_ucoeff,tol=0.0)
                        
                        tfTransformed_Actrb, tfTransformed_Bctrb, tfTransformed_Cctrb, tfTransformed_nctrb,\
                            tfTransformed_index, tfTransformed_dcoeff, tfTransformed_ucoeff = tb04ad(\
                            ssTransformed_nr,inputs,outputs,ssTransformed_A, ssTransformed_B, ssTransformed_C,\
                            ssTransformed_D,tol1=0.0)

                        numTransformed = np.array(tfTransformed_ucoeff)
                        denTransformed = np.array(tfTransformed_dcoeff)
                        numOriginal = np.array(tfOriginal_ucoeff)
                        denOriginal = np.array(tfOriginal_dcoeff)
                                              
                        ssTransformed = matlab.ss(ssTransformed_A,ssTransformed_B,ssTransformed_C,ssTransformed_D)
                        for inputNum in range(inputs):
                            for outputNum in range(outputs):
                                [ssOriginalMag,ssOriginalPhase,freq] = matlab.bode(ssOriginal,Plot=False) 
                                [tfOriginalMag,tfOriginalPhase,freq] = matlab.bode(matlab.tf(numOriginal[outputNum][inputNum],denOriginal[outputNum]),Plot=False)
                                [ssTransformedMag,ssTransformedPhase,freq] = matlab.bode(ssTransformed,freq,Plot=False)
                                [tfTransformedMag,tfTransformedPhase,freq] = matlab.bode(matlab.tf(numTransformed[outputNum][inputNum],denTransformed[outputNum]),freq,Plot=False)
                                #print 'numOrig=',numOriginal[outputNum][inputNum]
                                #print 'denOrig=',denOriginal[outputNum]
                                #print 'numTrans=',numTransformed[outputNum][inputNum]
                                #print 'denTrans=',denTransformed[outputNum]
                                np.testing.assert_array_almost_equal(ssOriginalMag,tfOriginalMag,decimal=3)
                                np.testing.assert_array_almost_equal(ssOriginalPhase,tfOriginalPhase,decimal=3)       
                                np.testing.assert_array_almost_equal(ssOriginalMag,ssTransformedMag,decimal=3)
                                np.testing.assert_array_almost_equal(ssOriginalPhase,ssTransformedPhase,decimal=3)
                                np.testing.assert_array_almost_equal(tfOriginalMag,tfTransformedMag,decimal=3)
                                np.testing.assert_array_almost_equal(tfOriginalPhase,tfTransformedPhase,decimal=2)
Example #5
0
    def testFreqResp(self):
        """Compare the bode reponses of the SS systems and TF systems to the original SS
           They generally are different realizations but have same freq resp.
           Currently this test may only be applied to SISO systems.
        """
        from slycot import tb04ad, td04ad
        for states in range(1, self.maxStates):
            for testNum in range(self.numTests):
                for inputs in range(1, 1):
                    for outputs in range(1, 1):
                        ssOriginal = matlab.rss(states, outputs, inputs)

                        tfOriginal_Actrb, tfOriginal_Bctrb, tfOriginal_Cctrb,\
                            tfOrigingal_nctrb, tfOriginal_index,\
                            tfOriginal_dcoeff, tfOriginal_ucoeff = tb04ad(
                                states, inputs, outputs, ssOriginal.A,
                                ssOriginal.B, ssOriginal.C, ssOriginal.D,
                                tol1=0.0)

                        ssTransformed_nr, ssTransformed_A, ssTransformed_B,\
                            ssTransformed_C, ssTransformed_D\
                            = td04ad('R', inputs, outputs, tfOriginal_index,
                                     tfOriginal_dcoeff, tfOriginal_ucoeff,
                                     tol=0.0)

                        tfTransformed_Actrb, tfTransformed_Bctrb,\
                            tfTransformed_Cctrb, tfTransformed_nctrb,\
                            tfTransformed_index, tfTransformed_dcoeff,\
                            tfTransformed_ucoeff = tb04ad(
                                ssTransformed_nr, inputs, outputs,
                                ssTransformed_A, ssTransformed_B,
                                ssTransformed_C, ssTransformed_D,
                                tol1=0.0)

                        numTransformed = np.array(tfTransformed_ucoeff)
                        denTransformed = np.array(tfTransformed_dcoeff)
                        numOriginal = np.array(tfOriginal_ucoeff)
                        denOriginal = np.array(tfOriginal_dcoeff)

                        ssTransformed = matlab.ss(ssTransformed_A,
                                                  ssTransformed_B,
                                                  ssTransformed_C,
                                                  ssTransformed_D)
                        for inputNum in range(inputs):
                            for outputNum in range(outputs):
                                [ssOriginalMag, ssOriginalPhase, freq] =\
                                    matlab.bode(ssOriginal, plot=False)
                                [tfOriginalMag, tfOriginalPhase, freq] =\
                                    matlab.bode(matlab.tf(
                                        numOriginal[outputNum][inputNum],
                                        denOriginal[outputNum]), plot=False)
                                [ssTransformedMag, ssTransformedPhase, freq] =\
                                    matlab.bode(ssTransformed,
                                                freq, plot=False)
                                [tfTransformedMag, tfTransformedPhase, freq] =\
                                    matlab.bode(matlab.tf(
                                        numTransformed[outputNum][inputNum],
                                        denTransformed[outputNum]),
                                        freq, plot=False)
                                # print('numOrig=',
                                #  numOriginal[outputNum][inputNum])
                                # print('denOrig=',
                                #  denOriginal[outputNum])
                                # print('numTrans=',
                                #  numTransformed[outputNum][inputNum])
                                # print('denTrans=',
                                #  denTransformed[outputNum])
                                np.testing.assert_array_almost_equal(
                                    ssOriginalMag, tfOriginalMag, decimal=3)
                                np.testing.assert_array_almost_equal(
                                    ssOriginalPhase,
                                    tfOriginalPhase,
                                    decimal=3)
                                np.testing.assert_array_almost_equal(
                                    ssOriginalMag, ssTransformedMag, decimal=3)
                                np.testing.assert_array_almost_equal(
                                    ssOriginalPhase,
                                    ssTransformedPhase,
                                    decimal=3)
                                np.testing.assert_array_almost_equal(
                                    tfOriginalMag, tfTransformedMag, decimal=3)
                                np.testing.assert_array_almost_equal(
                                    tfOriginalPhase,
                                    tfTransformedPhase,
                                    decimal=2)
Example #6
0
def _convertToTransferFunction(sys, **kw):
    """Convert a system to transfer function form (if needed).

    If sys is already a transfer function, then it is returned.  If sys is a
    state space object, then it is converted to a transfer function and
    returned.  If sys is a scalar, then the number of inputs and outputs can be
    specified manually, as in:

    >>> sys = _convertToTransferFunction(3.) # Assumes inputs = outputs = 1
    >>> sys = _convertToTransferFunction(1., inputs=3, outputs=2)

    In the latter example, sys's matrix transfer function is [[1., 1., 1.]
                                                              [1., 1., 1.]].

    If sys is an array-like type, then it is converted to a constant-gain
    transfer function.

    >>> sys = _convertToTransferFunction([[1. 0.], [2. 3.]])

    In this example, the numerator matrix will be
       [[[1.0], [0.0]], [[2.0], [3.0]]]
    and the denominator matrix [[[1.0], [1.0]], [[1.0], [1.0]]]

    """
    from .statesp import StateSpace

    if isinstance(sys, TransferFunction):
        if len(kw):
            raise TypeError("If sys is a TransferFunction, " +
                            "_convertToTransferFunction cannot take keywords.")

        return sys
    elif isinstance(sys, StateSpace):

        if 0 == sys.states:
            # Slycot doesn't like static SS->TF conversion, so handle
            # it first.  Can't join this with the no-Slycot branch,
            # since that doesn't handle general MIMO systems
            num = [[[sys.D[i, j]] for j in range(sys.inputs)]
                   for i in range(sys.outputs)]
            den = [[[1.] for j in range(sys.inputs)]
                   for i in range(sys.outputs)]
        else:
            try:
                from slycot import tb04ad
                if len(kw):
                    raise TypeError(
                        "If sys is a StateSpace, " +
                        "_convertToTransferFunction cannot take keywords.")

                # Use Slycot to make the transformation
                # Make sure to convert system matrices to numpy arrays
                tfout = tb04ad(sys.states,
                               sys.inputs,
                               sys.outputs,
                               array(sys.A),
                               array(sys.B),
                               array(sys.C),
                               array(sys.D),
                               tol1=0.0)

                # Preallocate outputs.
                num = [[[] for j in range(sys.inputs)]
                       for i in range(sys.outputs)]
                den = [[[] for j in range(sys.inputs)]
                       for i in range(sys.outputs)]

                for i in range(sys.outputs):
                    for j in range(sys.inputs):
                        num[i][j] = list(tfout[6][i, j, :])
                        # Each transfer function matrix row
                        # has a common denominator.
                        den[i][j] = list(tfout[5][i, :])

            except ImportError:
                # If slycot is not available, use signal.lti (SISO only)
                if (sys.inputs != 1 or sys.outputs != 1):
                    raise TypeError("No support for MIMO without slycot")

                # Do the conversion using sp.signal.ss2tf
                # Note that this returns a 2D array for the numerator
                num, den = sp.signal.ss2tf(sys.A, sys.B, sys.C, sys.D)
                num = squeeze(num)  # Convert to 1D array
                den = squeeze(den)  # Probably not needed

        return TransferFunction(num, den, sys.dt)

    elif isinstance(sys, (int, float, complex, np.number)):
        if "inputs" in kw:
            inputs = kw["inputs"]
        else:
            inputs = 1
        if "outputs" in kw:
            outputs = kw["outputs"]
        else:
            outputs = 1

        num = [[[sys] for j in range(inputs)] for i in range(outputs)]
        den = [[[1] for j in range(inputs)] for i in range(outputs)]

        return TransferFunction(num, den)

    # If this is array-like, try to create a constant feedthrough
    try:
        D = array(sys)
        outputs, inputs = D.shape
        num = [[[D[i, j]] for j in range(inputs)] for i in range(outputs)]
        den = [[[1] for j in range(inputs)] for i in range(outputs)]
        return TransferFunction(num, den)
    except Exception as e:
        print("Failure to assume argument is matrix-like in"
              " _convertToTransferFunction, result %s" % e)

    raise TypeError("Can't convert given type to TransferFunction system.")
def _convertToTransferFunction(sys, **kw):
    """Convert a system to transfer function form (if needed).

    If sys is already a transfer function, then it is returned.  If sys is a
    state space object, then it is converted to a transfer function and
    returned.  If sys is a scalar, then the number of inputs and outputs can be
    specified manually, as in:

    >>> sys = _convertToTransferFunction(3.) # Assumes inputs = outputs = 1
    >>> sys = _convertToTransferFunction(1., inputs=3, outputs=2)

    In the latter example, sys's matrix transfer function is [[1., 1., 1.]
                                                              [1., 1., 1.]].

    If sys is an array-like type, then it is converted to a constant-gain
    transfer function.

    >>> sys = _convertToTransferFunction([[1. 0.], [2. 3.]])

    In this example, the numerator matrix will be
       [[[1.0], [0.0]], [[2.0], [3.0]]]
    and the denominator matrix [[[1.0], [1.0]], [[1.0], [1.0]]]

    """
    from .statesp import StateSpace

    if isinstance(sys, TransferFunction):
        if len(kw):
            raise TypeError("If sys is a TransferFunction, " +
                            "_convertToTransferFunction cannot take keywords.")

        return sys
    elif isinstance(sys, StateSpace):
        try:
            from slycot import tb04ad
            if len(kw):
                raise TypeError(
                    "If sys is a StateSpace, " +
                    "_convertToTransferFunction cannot take keywords.")

            # Use Slycot to make the transformation
            # Make sure to convert system matrices to numpy arrays
            tfout = tb04ad(sys.states, sys.inputs, sys.outputs, array(sys.A),
                           array(sys.B), array(sys.C), array(sys.D), tol1=0.0)

            # Preallocate outputs.
            num = [[[] for j in range(sys.inputs)] for i in range(sys.outputs)]
            den = [[[] for j in range(sys.inputs)] for i in range(sys.outputs)]

            for i in range(sys.outputs):
                for j in range(sys.inputs):
                    num[i][j] = list(tfout[6][i, j, :])
                    # Each transfer function matrix row
                    # has a common denominator.
                    den[i][j] = list(tfout[5][i, :])
            # print(num)
            # print(den)
        except ImportError:
            # If slycot is not available, use signal.lti (SISO only)
            if (sys.inputs != 1 or sys.outputs != 1):
                raise TypeError("No support for MIMO without slycot")

            lti_sys = lti(sys.A, sys.B, sys.C, sys.D)
            num = squeeze(lti_sys.num)
            den = squeeze(lti_sys.den)
            # print(num)
            # print(den)

        return TransferFunction(num, den, sys.dt)

    elif isinstance(sys, (int, float, complex)):
        if "inputs" in kw:
            inputs = kw["inputs"]
        else:
            inputs = 1
        if "outputs" in kw:
            outputs = kw["outputs"]
        else:
            outputs = 1

        num = [[[sys] for j in range(inputs)] for i in range(outputs)]
        den = [[[1] for j in range(inputs)] for i in range(outputs)]

        return TransferFunction(num, den)

    # If this is array-like, try to create a constant feedthrough
    try:
        D = array(sys)
        outputs, inputs = D.shape
        num = [[[D[i, j]] for j in range(inputs)] for i in range(outputs)]
        den = [[[1] for j in range(inputs)] for i in range(outputs)]
        return TransferFunction(num, den)
    except Exception as e:
        print("Failure to assume argument is matrix-like in"
              " _convertToTransferFunction, result %s" % e)

    raise TypeError("Can't convert given type to TransferFunction system.")
Example #8
0
def _convertToTransferFunction(sys, **kw):
    """Convert a system to transfer function form (if needed).
    
    If sys is already a transfer function, then it is returned.  If sys is a
    state space object, then it is converted to a transfer function and
    returned.  If sys is a scalar, then the number of inputs and outputs can be
    specified manually, as in:

    >>> sys = _convertToTransferFunction(3.) # Assumes inputs = outputs = 1
    >>> sys = _convertToTransferFunction(1., inputs=3, outputs=2)

    In the latter example, sys's matrix transfer function is [[1., 1., 1.]
                                                              [1., 1., 1.]].
    
    """
    
    if isinstance(sys, TransferFunction):
        if len(kw):
            raise TypeError("If sys is a TransferFunction, \
_convertToTransferFunction cannot take keywords.")

        return sys
    elif isinstance(sys, statesp.StateSpace):
        try:
            from slycot import tb04ad
            if len(kw):
                raise TypeError("If sys is a StateSpace, \
                        _convertToTransferFunction cannot take keywords.")

            # Use Slycot to make the transformation
            # Make sure to convert system matrices to numpy arrays
            tfout = tb04ad(sys.states, sys.inputs, sys.outputs, array(sys.A),
                           array(sys.B), array(sys.C), array(sys.D), tol1=0.0)

            # Preallocate outputs.
            num = [[[] for j in range(sys.inputs)] for i in range(sys.outputs)]
            den = [[[] for j in range(sys.inputs)] for i in range(sys.outputs)]

            for i in range(sys.outputs):
                for j in range(sys.inputs):
                    num[i][j] = list(tfout[6][i, j, :])
                    # Each transfer function matrix row has a common denominator.
                    den[i][j] = list(tfout[5][i, :])
            # print num
            # print den
        except ImportError:
            # If slycot is not available, use signal.lti (SISO only)
            if (sys.inputs != 1 or sys.outputs != 1):
                raise TypeError("No support for MIMO without slycot")

            lti_sys = lti(sys.A, sys.B, sys.C, sys.D)
            num = squeeze(lti_sys.num)
            den = squeeze(lti_sys.den)
            print num
            print den

        return TransferFunction(num, den)
    elif isinstance(sys, (int, long, float, complex)):
        if "inputs" in kw:
            inputs = kw["inputs"]
        else:
            inputs = 1
        if "outputs" in kw:
            outputs = kw["outputs"]
        else:
            outputs = 1

        num = [[[sys] for j in range(inputs)] for i in range(outputs)]
        den = [[[1] for j in range(inputs)] for i in range(outputs)]
        
        return TransferFunction(num, den)
    else:
        raise TypeError("Can't convert given type to TransferFunction system.")