# routh_table
This dir is belong to Control System class contains with Automated Routh Table Calculator based on Python. This code 100% original made by my hand :), please leave some notes if you're going to use it. Thanks!

## Libraries
Libraries that used in this program is ```numpy``` and ```pandas```. ```numpy``` works to define and perform array while ```pandas``` is the final form after ```numpy.array``` to simplify the presentation. They imported by write..
```
import numpy as np
import pandas as pd
```

## RouthStability Class
This class contains lots of procedures to simplify our Routh Stability Table Generator process. 
```
def __init__(self, den):
    self.den = np.array([float(item) for item in den.split()])
    self.deg = len(self.den)
```
The constructor ```__init__``` takes string of coefficiens from polynomial, extract the number, and load into class variable. It also define ```self.deg``` variable to save array's length, reducing number to calling ```len()``` function

```
def set_k(self, k):
    self.den = np.append(self.den, float(k))
    self.deg += 1
```
This function only takes one number from user and append it to ```self.den``` which defined as gain (constant). Also ```self.deg``` will increase by one

```
def calc_routh(self):
    height = (self.deg+1)//2
    arr = np.zeros((height + 2,height))
    for index in range(self.deg):
        if index % 2 == 0:
        arr[0][index//2] = self.den[index]
        else:
        arr[1][(index-1)//2] = self.den[index]

    for i in range(2, height+2):
        for j in range(height-1):
        arr[i][j] = (arr[i-1][0]*arr[i-2][j+1] - arr[i-2][0]*arr[i-1][j+1])/arr[i-1][0]
        arr[i][j] += 0

    self.df = pd.DataFrame(arr)
    self.show_tab()
    if self.is_stable() == True:
        print("SYSTEM IS STABLE")
    else:
        print("SYSTEM IS UNSTABLE")
```
```calc_routh(self)``` as the core process of this class contains initialization and process about Routh Stability Process. Firstly, it define an empty zero (basically it filled with zeros) and iteratively being inserted by ```self.den``` (refering to Routh Table principle). After that, each cell will be updated by calculating Routh Table formula. Routh Table defined as ```numpy.ndarray``` and converted to ```pandas.DataFrame``` to simplify the presentation of table. ```self.show_tab()``` is called to print the Routh Table and ```self.is_stable()``` to check system's stability.

```
def show_tab(self):
    print(self.df)
```
This function print the Routh Table, should be called only if Routh Table is generated by ```calc_routh```

```
def get_table(self):
    return self.df
```
This function return ```pandas.DataFrame``` contained by Routh Table

```
def is_stable(self):
    flag = True
    for item in self.df[0]:
        if item < 0: flag = False
    return flag
```
This function check the first column's value from Routh Table. The system is define as stable if and only if all the value is positive, else it's unstable

```
def get_poly(self, x):
    total = 0
    for i in range(self.deg):
        total += self.den[self.deg-i-1]*(x**i)
        print(total)
    return total
```
This function initialize ```x``` value as variable on ```self.den``` polynomial and return the total

## Testing 1
The testing can follow below example:
```
# First Testing
den = input("Enter your polynomial: ")
k_in = input("Enter your K: ")

rs = RouthStability(den)
rs.set_k(k_in)
rs.calc_routh()
```
It takes coefficient of polynomial and K from user, insert it into ```RouthStability``` class as constructor parameter, insert the K value, and generate Routh Table. The result can be found below:
```
Enter your polynomial: 1 3 5 7
Enter your K: 9
          0    1    2
0  1.000000  5.0  9.0
1  3.000000  7.0  0.0
2  2.666667  9.0  0.0
3 -3.125000  0.0  0.0
4  9.000000 -0.0  0.0
SYSTEM IS UNSTABLE
```

## Testing 2
```
Enter your polynomial: 11 15 19 21
Enter your K: 29
           0     1     2
0  11.000000  19.0  29.0
1  15.000000  21.0   0.0
2   3.600000  29.0   0.0
3 -99.833333   0.0   0.0
4  29.000000  -0.0   0.0
SYSTEM IS UNSTABLE
```

## Testing 3
```
Enter your polynomial: 1.2 6.78 11.11
Enter your K: 3.141
           0       1
0   1.200000  11.110
1   6.780000   3.141
2  10.554071   0.000
3   3.141000   0.000
SYSTEM IS STABLE
```
### Notes
Contact nanda.r.d@mail.ugm.ac.id for more information
### Links
You can access the source code here
[github.com/nandard/control-system.git](https://github.com/nandard/control-system.git)