The Roth-Hurwitz קריטריון: A Cornerstone of Control Systems Analysis

הקריטריון של רוס-הורוויץ הוא שיטה בסיסית בהנדסה שליטה המשמשת כדי לקבוע את יציבותה של מערכת המבוססת על המשוואה האופיינית שלה באופן מסורתי, ביצוע בדיקות אלה באופן ידני יכול להיות זמן-consuming ו prone שגיאות, במיוחד כאשר סדר המערכת עולה.אוטומטי התהליך עם תסריטי פייתון משפר באופן משמעותי את יעילות ודיוק, המאפשר למהנדסים לנתח פולינואלים גבוהים, לשלב במהירות יציבות לתוך בדיקות אוטומטיות של חישובים אוטומטיים.

מאמר זה מספק מדריך מקיף לאוטומט בדיקות יציבות של רות'-הורוויץ באמצעות Python.זה מכסה את הרקע המתמטי, יישום פרטים, טיפול במקרים מיוחדים, ושילוב מעשי לתוך זרימות עבודה הנדסיות.עד הסוף, אתה תהיה מצויד לכתוב תסריטים חזקים שיכולים לעבד הגדרות מערכת מרובות, להתמודד עם קידוד סימבולי, לייצר הערכות יציבות ברורות.

מה זה הקריטריון של רות-הורוויץ?

לאחר אדוארד ג'ון רות' ו אדולף הרביץ, הקריטריון מספק תנאים הכרחיים ומספיקים ליציבות של מערכת זמן ליניארית (LTI) עבור פולינומאלית אופיינית:

(ב) 0 ו- 0;

השיטה בונה את מערך רוס מהמתקני ה-Coefficients.המערכת יציבה אם ורק אם כל האלמנטים בעמודה הראשונה של המערך הם חיוביים.כל שינוי סימן מצביע על קטבים לא יציבים, ואפס בעמודה הראשונה או שורה שלמה של אפס נקודות ליציבות שולית או נוכחות של שורשים ממוקמים באופן סימטרי.

הקריטריון משמש נרחב כי הוא נמנע לפתור את הפולנומיאל עצמו ופועל ישירות עם משככי כפיים.עם זאת, בנייה ידנית עבור פולינומיסים של תואר 5 או גבוה יותר הופכת להיות מייגעת שגיאות וטעייה, מה שהופך את האוטומציה למאוד חשובה.

למה לבדוק את האפשרות האוטומטית?

אוטומטי של הליך רוס-הורוויץ מציע יתרונות משמעותיים הן במסגרות אקדמיות והן תעשייתיות:

  • (FLT:0Speed andיעילות: FLT:1) תסריט יכול להעריך עשרות פולינומיס לשנייה, המאפשרת השקיה מהירה במהלך כוונון בקר או זיהוי מערכת.
  • (ב) ,0) דיוקנות: 1FLT מבטל שגיאות קידוד המתרחשות בדרך כלל בעת בניית מערך ביד, במיוחד כאשר מדובר באפקטים שבריריים או סמליים.
  • (FLT:0)Parameter גורפת: מהנדסים 1FLT יכולים להשתנות באופן שיטתי, קבוע זמן, או פרמטרים אחרים עיצוב, מיד לראות את ההשפעה על יציבות גבולות.
  • (FLT:0) אינטגרציה עם סימולציות גדולות יותר:ראה פרק 1:) ניתן להטמיע את בדיקת היציבות בלולאות אופטימיזציה, מונטה קרלו ניתוחים, או תסריטי עיצוב אוטומטיים.
  • (FLT:0) שיפור: כתוביות 1FLT מספקות ניתוח מתועדו, מבוקר גרסאות שניתן לשתף בקלות ולבחון אותו.

על ידי הסרת חישוב שגרתית ל- Python, מהנדסים יכולים להתמקד בהחלטות עיצוב ברמה גבוהה יותר ופרשנות של תוצאות.

יסודות הבנייה של הרות' ארי

לפני כתיבת קוד, חיוני להבין את האלגוריתם, התסריט חייב לעקוב.בהתחשב פולינומאלי של תואר n:

  1. הסדר את האפקטיביות בשני שורות: השורה הראשונה מכילה אפקטיביות של אפילו סמכויות (החל מהכוח הגבוה ביותר), והשורה השנייה מכילה אפקטיביות של כוחות מוזרים.לדוגמה, עבור מסדר חמישי של A0s5 + A1s4 + A2s3 + A3 + A3s2s + A5, הראשון הוא [a0,2, a2, a3] השני, 2.
  2. שורת פאד עם אפסים כדי להבטיח אורך שווה במידת הצורך.
  3. שורות עוקבות נוספות באמצעות הנוסחה:

(בשם א) הוא היסוד הראשון של השורה הקודמת.

חזור עד למערך יש שורות N+1.

קצבה חשובה: אם אפס מופיע בעמודה הראשונה של שורה, הנוסחה הסטנדרטית נכשלת.המבנה של מערך רוס חייב להתמודד עם מקרים מיוחדים:

  • (בעמודה הראשונה (אך לא כל אפסים בשורה): החלפה 1:1 עם מספר חיובי קטן ε, המשך הבנייה, ולאחר מכן לבחון את הסימנים כ ε.
  • (השורה התחתונה של אפסים: ⁇ 1) זה מצביע על נוכחות של שורשים חד-סימטריים (למשל, סגדו מורכב על הציר הדמיוני, או זוגות שורשים עם סימנים מנוגדים).

תסריט אוטומציה חזק חייב לזהות ולתקל כראוי בשני המקרים.

יישום רוס-הורוויץ' אלגואטרם ב- Python

Libraries and Setup

אנו נשתמש ב-FLT:0 symPyofph:1 למתמטיקה סמלית ו- (FLT:2NumPycioFLT 3 עבור חישובים נומרניים. SymPy הוא בעל ערך במיוחד כאשר coefficients כרוכים פרמטרים (למשל, רווחים לא ידועים) כי הם לא מספריים בלבד.

המונחים: different

התסריט הפשוט ביותר מקבל רשימה של מזהמים מספריים (float או integer) ונבנה את מערך רוס באמצעות קידוד צף.למטה הוא גרסה עדכנית ומורחבה של הקוד הבסיסי:

import numpy as np

def routh_hurwitz_numeric(coeffs):
 """
 Construct the Routh array for a polynomial with numeric coefficients.
 coeffs: list of coefficients from highest power down (a0, a1, ..., an)
 Returns a tuple (array, stability: str) or raises ValueError if first element is zero.
 """
 if coeffs[0] <= 0:
 raise ValueError("Coefficient a0 must be positive for standard Routh-Hurwitz.")
 n = len(coeffs) - 1
 # Build first two rows
 row1 = np.array([coeffs[i] for i in range(0, n+1, 2)], dtype=float)
 row2 = np.array([coeffs[i] for i in range(1, n+1, 2)], dtype=float)
 # Pad to same length
 max_len = max(len(row1), len(row2))
 row1 = np.pad(row1, (0, max_len - len(row1)))
 row2 = np.pad(row2, (0, max_len - len(row2)))
 routh = [row1.tolist(), row2.tolist()]

 for i in range(2, n+1):
 if routh[-1][0] == 0:
 # Special case: zero in first column
 # Replace with small epsilon (here we modify the row)
 routh[-1][0] = 1e-10 # Use a tiny positive number
 # Mark that epsilon was used (for sign analysis)
 # For simplicity, we assume epsilon > 0; later we can refine
 row = []
 for j in range(len(routh[0]) - 1):
 a = routh[i-2][0]
 b = routh[i-2][j+1] if j+1 < len(routh[i-2]) else 0
 c = routh[i-1][0]
 d = routh[i-1][j+1] if j+1 < len(routh[i-1]) else 0
 if c == 0:
 row.append(0) # Not reached because we handled epsilon above
 else:
 row.append((c * b - a * d) / c)
 if all(abs(x) < 1e-12 for x in row):
 # Entire row of zeros -> handle auxiliary polynomial
 return handle_auxiliary_row(routh, row, coeffs)
 routh.append(row)
 # Check stability
 first_col = [routh[i][0] for i in range(n+1)]
 if all(x > 0 for x in first_col):
 return routh, "Stable"
 else:
 return routh, "Unstable"

def handle_auxiliary_row(routh, zero_row, coeffs):
 # Extract row above zero row (the one that generated the auxiliary polynomial)
 prev_row = routh[-1]
 # Build auxiliary polynomial from prev_row: s^? (using degrees)
 # This is a simplified placeholder; full implementation requires polynomial differentiation
 # For detail, see reference.
 # For now, we raise an error indicating advanced handling needed.
 raise NotImplementedError("Entire row of zeros: auxiliary polynomial method required. Consider using sympy implementation.")

בעוד יישום מספרי זה עובד עבור מקרים רבים, זה הופך שברירי ליד יחידות.גישה ε-replacement דורש מעקב זהיר של שינויים בסימן. שיטה חזקה יותר משתמשת epsilon סמלי עם סימפפיפיפי.

המונחים: SymPy

יכולות האנתרופולוגיה והגבולות של סימפי מאפשרות טיפול נקי ומדויק במקרי אפס וטקס עזר.כאן מדובר בגרסה סמלית מלאה:

import sympy as sp

def routh_hurwitz_symbolic(coeffs):
 """
 coeffs: list of symbolic or numeric coefficients (a0, a1, ..., an), a0 > 0.
 Returns the Routh array (list of lists) and a stability message.
 """
 coeffs = [sp.sympify(c) for c in coeffs]
 n = len(coeffs) - 1
 # First two rows
 row1 = [coeffs[i] for i in range(0, n+1, 2)]
 row2 = [coeffs[i] for i in range(1, n+1, 2)]
 # Pad
 max_len = max(len(row1), len(row2))
 row1 += [0] * (max_len - len(row1))
 row2 += [0] * (max_len - len(row2))
 routh = [row1, row2]

 epsilon = sp.symbols('epsilon', positive=True)

 for i in range(2, n+1):
 prev_row1 = routh[i-2]
 prev_row2 = routh[i-1]
 first_prev = prev_row2[0]
 # Check for zero in first column
 if first_prev == 0:
 if all(x == 0 for x in prev_row2):
 # Entire row of zeros
 # Build auxiliary polynomial from previous row
 # Ex: if row above zero row is [a, b, c, ...] -> auxiliary poly: a*s^? + b*s^? + ...
 # Need to reconstruct degrees. Function robuster needed.
 # For brevity, we refer to the extended implementation.
 return routh, "Marginal stability detected; auxiliary polynomial needed"
 else:
 # Replace zero with epsilon
 prev_row2 = [epsilon if j == 0 else prev_row2[j] for j in range(len(prev_row2))]
 first_prev = epsilon
 new_row = []
 for j in range(len(prev_row1) - 1):
 a = prev_row1[0]
 b = prev_row1[j+1] if j+1 < len(prev_row1) else 0
 c = first_prev
 d = prev_row2[j+1] if j+1 < len(prev_row2) else 0
 if c == 0:
 value = 0
 else:
 value = (c * b - a * d) / c
 new_row.append(sp.simplify(value))
 # Simplify the row
 new_row = [sp.simplify(x) for x in new_row]
 routh.append(new_row)
 # After building row, if epsilon was used, take limit epsilon -> 0+
 # This simplifies the row to a numeric result if possible.
 if epsilon in sp.flatten([sp.preorder_traversal(x) for x in new_row]):
 new_row = [sp.limit(x, epsilon, 0) for x in new_row]
 routh[-1] = new_row

 # Check first column signs
 first_col = [routh[i][0] for i in range(n+1)]
 # If any symbol still present, cannot decide numerically; user must substitute.
 if any(sp.sympify(x).has(sp.Symbol) for x in first_col):
 return routh, "Indeterminate due to symbolic parameters; substitute numeric values."
 signs = [sp.sign(x) for x in first_col]
 if all(s == 1 for s in signs):
 return routh, "Stable"
 elif any(s == -1 for s in signs):
 return routh, "Unstable"
 else:
 return routh, "Marginal stability (zeros in first column)"

גרסה סמלית זו מטפלת נכון אפסים, ועם לוגיקה נוספת, יכולה לנהל שורות שלמות של אפסים.זה אידיאלי עבור ניתוחים פרמטריים שבהם coefficients מכילים משתנים סמליים כמו FLT:4.

שורה שלמה של Zeros

(הופנה מהדף "הלאפסים" (ה) יש לעבור לשיטת פולינומאלית העזרית (Autoy Polynomial) (ה-Autoy Polynomial Method) של ה-Autoy Polynomial) אשר נוצרה מן השורה ישירות מעל ל- Zero-Hpimal לספק את החלפת ה-F: לדוגמה: LTS1P:

בדיקות ואימות

כל תסריט אוטומטי צריך להיבדק נגד מקרים ידועים.לייצר חבילת מבחן המכסה:

  • (ב) ,5 (ב)
  • פולינומיס בלתי צפוי (למשל, FLT:6)> לא יציב בגלל שינוי סימן
  • פולינומיס עם אפס בעמודה ראשונה (למשל, FLT 7) > שולי או בלתי יציב בהתאם לשורשים).
  • פולינומיס עם שורה שלמה של אפסים (למשל, FLT:8)
  • פולינומיס (למשל, תואר 10) כדי לאמת את הביצועים.

השוואת תוצאות עם חישוב ידני או תפוקה ידועה של הספרייה הלאומית:0 שליטה הספרייה (FLT:9cioFLT:1 או ייעודי רול)

שילוב לתוך סוללות עבודה הנדסה

ברגע שהתסריט אמין, לשלב אותו בסביבה רחבה יותר של פייתון:

« « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « « פרדוקס « « « « « « « « « « « « « « « « « « פשטושטוף מתחזהירים מתחזהירים ו פשטושטוף פשטושטוף פשטושטוף פשטושטוף פשטושטוף ו פשטושול מתחו ושיטוט ושיטוט ומפללוט פשטושול פשטו ושיטוט ומפללוט

השתמש ב- NumPy או pandas כדי ליצור רשת של ערכי פרמטר (למשל, להרוויח K מ 0 עד 100) עבור כל ערך, לחדד את התקני פולינומאלי האופייניים (באמצעות תפקוד העברת המערכת), להפעיל את בדיקת היציבות ולאחסן את התוצאה.

import numpy as np
import matplotlib.pyplot as plt
from control import tf, feedback

def check_stability_for_gain(K):
 # Example: unity feedback with plant G(s) = K/(s^3 + 3s^2 + 2s)
 G = tf([K], [1, 3, 2, 0])
 T = feedback(G, 1)
 poly = T.den[0][0] # denominator coefficients
 stable = routh_hurwitz_numeric(poly) # call your function
 return stable

Ks = np.linspace(0, 20, 100)
stable_list = [check_stability_for_gain(K) for K in Ks]
plt.plot(Ks, stable_list)
plt.xlabel('Gain K')
plt.ylabel('Stable (1) / Unstable (0)')
plt.show()

מזימה כזו חושפת במהירות את שולי היציבות (למשל, שולי הרווח שבהם משתנה יציבות).

אופטימיזציה אוטומטית

הטמיעו את ה-Valce Check כ-Conventt in Optimization.לדוגמה, השתמשו ב-Sipy.optimize כדי למזער את תפקוד העלות תוך שימתו של הקריטריון של רוס-הורוויץ' כדי להחזיר את "Stable".הגרסה הסמלית מאפשרת הערכה ללא ⁇ .

עקבו אחרי Jupyter Notebooks

המחברות של ג'ופטר הן אידיאליות לניתוח אינטראקטיבי.שלב את הפונקציה רוס-הורוויץ עם הדפסה יפה של סינמפי כדי להציג את מערך צעד אחר צעד, מה שהופך אותו חינוכי ו debuggable.

שיקולים מתקדמים

המונחים: Precision

עבור טבלאות צף, האלגוריתם עשוי לסבול משגיאות ביטול. השתמש ב- SymPy עם מספרים רציונליים כאשר ניתן, או להשתמש בצפיפות גבוהות דרך FLT:11 ( לחלופין, FLT:0numpy.polinomialמודולFLT:1 יכול למקם שורשים ישירות, אשר הוא פשוט עבור פולימיס מספריים, עם זאת, שיטת Rön-Hurwitz נותן תובנה לעתים קרובות ללא פתרון שורשים.

המונחים: astures

כאשר coefficients כרוכים סמלים (למשל, K, ⁇ ), התסריט עשוי לייצר ביטויים הדורשים ניתוח סימנים ידני. השתמש ב-SamPy'sFLT:12 עם הנחות כדי לפשט על בסיס מגוון ידוע (למשל, K > 0). זה יכול באופן חלקי להעביר את ההחלטה היציבות.

המונחים

עבור פרמטר גדול גורף, במקביל לשימוש ב-FLT:13 או (FLT:14) כל בדיקת יציבות היא עצמאית.

מסקנות ועיסוקים טובים

אוטומטי של רוס-הורוויץ 'יציבות בודקת עם תסריטי פייתון הופך תהליך ידני מייגע לתוך כלי מהיר, אמין, ורחב.

  • התחל עם הבנה ברורה של האלגוריתם, כולל מקרים מיוחדים.
  • (ב) ,0) ,SymPyFLT:1 עבור קידוד סמלי וטיפול מדויק במקרה של אפס-רו.
  • (ב) ,0) ,NumPyFLT 1 עבור פולינומיס טהור כאשר מהירות היא רבת-חשיבות.
  • בדוק את היישום שלך עם מגוון של פולינומיס.
  • לחדד את הפונקציה לתוך צינורות ניתוח רחב יותר עבור עיצוב ואופטימיזציה.

על ידי ביצוע הדוגמאות וההנחיות במאמר זה, אתה יכול ליצור תסריטים אוטומציה חזקים המשמשים אבן הפינה של מערכות הבקרה שלך לעבוד.הזמן שנשמר יאפשר לך לחקור חלופות עיצוב יותר ולהשיג ביצועים טובים יותר של המערכת.

(ב) [ה]הקוד שסופק במאמר זה הוא למטרות חינוכיות.לשימוש בייצור, לשקול לתרום או אימוץ חבילות מבוססות כגון: FLT 3Python Control LibraryFOVAFLT:4, הכוללות פונקציות מחקר ניסיוניות היטב של רוסת-הורוויץ' ותפקודי ניתוח יציבות אחרים.

עם התסריטים ביד, אתה מוכן כעת להחלפת בדיקות יציבות עבור מערכות של כל סדר, שחרור האנרגיה הנפשית שלך לאתגרים היצירתיים של עיצוב מערכת הבקרה.