ujson安裝找不到對應版本

您好，很高興為您服務。

成都創新互聯"三網合一"的企業建站思路。企業可建設擁有電腦版、微信版、手機版的企業網站。實現跨屏營銷，產品發布一步更新，電腦網絡+移動網絡一網打盡，滿足企業的營銷需求！成都創新互聯具備承接各種類型的成都做網站、成都網站建設項目的能力。經過十余年的努力的開拓，為不同行業的企事業單位提供了優質的服務，并獲得了客戶的一致好評。

關于您提到的ujson安裝問題，我能為您提供一些幫助。首先，您需要確認自己的Python版本，因為ujson的版本與Python版本有關。如果您的Python版本是2.7，那么您可以使用pip來安裝ujson，命令如下：pip install ujson。如果您的Python版本是3.x，那么您可以使用pip3來安裝ujson，命令如下：pip3 install ujson。

此外，您也可以從Python官網上下載ujson的源碼，然后自行編譯安裝。您可以在Python官網上搜索“ujson”，找到ujson的源碼，下載后解壓，然后運行python setup.py install來安裝ujson。

最后，您也可以從第三方網站上下載ujson的安裝包，然后使用pip或pip3來安裝。您可以在網上搜索“ujson安裝包”，找到相應的安裝包，下載后使用pip或pip3來安裝即可。

總之，您可以根據自己的需要，選擇以上任意一種方式來安裝ujson。我希望我的回答能夠幫助您解決您的問題。

Python-os的path模塊函數大全

在操作文件的時候，我們肯定是要使用到 os 模塊的，但是 os 模塊里面還有 path 模塊，這個模塊主要是用來獲取文件的屬性的。這篇博客來分享一下 path 模塊的函數，希望對學習 Python 的小伙伴有所幫助。

返回絕對路徑：

返回文件名：

返回list(多個路徑)中，所有path共有的最長的路徑：

返回文件路徑：

路徑存在則返回True,路徑損壞返回False：

路徑存在則返回True,路徑損壞也返回True：

把path中包含的" "和" user"轉換成用戶目錄：

根據環境變量的值替換path中包含的" {name}"：

返回最近訪問時間（浮點型秒數）：

返回最近文件修改時間：

返回文件 path 創建時間：

返回文件大小，如果文件不存在就返回錯誤：

判斷是否為絕對路徑：

判斷路徑是否為文件：

判斷路徑是否為目錄：

判斷路徑是否為鏈接：

判斷路徑是否為掛載點：

把目錄和文件名合成一個路徑：

轉換path的大小寫和斜杠：

規范path字符串形式：

返回path的真實路徑：

從start開始計算相對路徑：

判斷目錄或文件是否相同：

判斷fp1和fp2是否指向同一文件:

判斷stat tuple stat1和stat2是否指向同一個文件:

把路徑分割成 dirname 和 basename，返回一個元組:

一般用在 windows 下，返回驅動器名和路徑組成的元組:

分割路徑中的文件名與拓展名:

把路徑分割為加載點與文件:

遍歷path，進入每個目錄都調用visit函數，visit函數必須有3個參數(arg, dirname, names)，dirname表示當前目錄的目錄名，names代表當前目錄下的所有文件名，args則為walk的第三個參數:

設置是否支持unicode路徑名:

跟軌跡畫好之后分析是用閉環傳遞函數分析嗎

那個就是上面式子的實部和虛部分開寫的得到兩個方程。求頻率w的時候先利用虛部的方程得到w的值。再帶入實部的方程中求得k值在時域分析中已經看到，控制系統的性能取決于系統的閉環傳遞函數，因此，可以根據系統閉環傳遞函數的零、極點研究控制系統性能。但對于高階系統，采用解析法求取系統的閉環特征方程根（閉環極點）通常是比較困難的，且當系統某一參數（如開環增益）發生變化時，又需要重新計算，這就給系統分析帶來很大的不便。

1948年，伊萬思根據反饋系統中開、閉環傳遞函數間的內在聯系，提出了求解閉環特征方程根的比較簡易的圖解方法，這種方法稱為根軌跡法。因為根軌跡法直觀形象，所以在控制工程中獲得了廣泛應用。根軌跡是當開環系統某一參數（如根軌跡增益 ）從零變化到無窮時，閉環特征方程的根在S平面上移動的軌跡。根軌跡增益K * 是首1形式開環傳遞函數對應的系數。

?

在介紹圖解法之前，先用直接求根的方法來說明根軌跡的含義。控制系統如上圖所示。其開環傳遞函數為:利用計算結果在S平面上描點并用平滑曲線將其連接，便得到K * （或K）從零變化到無窮大時閉環極點在S平面上移動的軌跡，即根軌跡，如下圖所示。圖中，根軌跡用粗實線表示，箭頭表示K * （或K）增大時兩條根軌跡移動的方向根軌跡的概念

開環系統某一參數從零變換到無窮，閉環系統特征方程式的根在s平面上變化的軌跡。其中某一參數主要是指根軌跡增益，當然也可以是系統中其他的實參數。

根軌跡方程

?

將上式寫為相角及模值條件，根據這兩個條件可以完全確定s平面上的根軌跡和根軌跡上的K*值。

?

根軌跡與系統性能

1 穩定性

當參數由零變化到無窮時，根軌跡不會越過虛軸進入s右半平面則說明系統對于所有的K值都是穩定的，如果根軌跡越過虛軸進入s右半平面，則系統進入不穩定的狀態。

2穩態特性

一般情況下，根軌跡圖上標注的參數不是開環增益而是根軌跡增益，根軌跡增益與穩態誤差系數之間僅相差一個比例常數，

3動態特性

當所有閉環極點都位于實軸上時，系統為過阻尼系統；

當極點重合時，系統為臨界阻尼系統；

當閉環極點為共軛復數極點，系統為欠阻尼系統，單位階躍響應是衰減振蕩過程，且超調量將隨著K值的增大而增大。

確定閉環系統的零極點

當根軌跡增益確定時，傳遞函數也同時確定下來了，那么閉環系統的零極點位置就在根軌跡上確定下來了，通過位置可以判斷系統的穩定性能。

打開CSDN，閱讀體驗更佳

matlab求系統根軌跡和系統增益,控制系統的根軌跡分析

一、根軌跡分析方法的概念所謂根軌跡是指，當開環系統某一參數從零變到無窮大時，閉環系統特征方程的根在s平面上的軌跡。一般來說，這一參數選作開環系統的增益K，而在無零極點對消時，閉環系統特征方程的根就是閉環傳遞函數的極點。根軌跡分析方法是分析和設計線性定常控制系統的圖解方法，使用十分簡便。利用它可以對系統進行各種性能分析，1．穩定性當開環增益K從零到無窮大變化時，圖中的根軌跡不會越過虛軸進入右半s平面...

繼續訪問

【自動控制原理】根軌跡Root Locus-筆記

重點掌握根的變化規律。從而設計控制器/補償器。“根”——“極點”（一樣的概念）一階系統比如這個系統傳遞函數為，對這個系統施加一個沖擊u(t)=，的Laplace變換=1。所以系統的輸出為，令s+a=0，得“根”P=-a進行Laplace的逆變換，得到這個系統的時間函數，這里的-a就是它的根當a0時，它在時間軸上的表現為指數衰減對于一般的一階系統來說，如果把它的根在復平面上(橫軸為實數,豎軸為虛數)表達出來的話，它一定落在實軸上，如圖一階函數的。...

繼續訪問

?

一階系統開環傳遞函數表達式_古典控制理論（三）根軌跡法（閉環系統）

1 根軌跡與系統性能（1）定義：指系統某一參數從零變化到無窮大時，閉環系統特征方程式的根（閉環極點）在s平面上變化的軌跡。 Matlab命令：rlocus(sys)，默認變化參數為開環傳遞函數的增益k。（2）功能：根軌跡可以直接給出閉環系統時間相應的全部信息，而且可以指明開環零、極點應該如何變化才能滿足給定的閉環系統的性能指標要求。 根軌跡方法可以求解高階代數方程的根，實際上就是解決閉環特征方程...

繼續訪問

傳遞函數根軌跡

根軌跡 以及時域響應，自動控制，各個方面的自動控制都有用，直接出根軌跡

Simulink模型閉環傳遞函數導出及Matlab對simulink模型進行頻域分析(含實現程序)

Simulink模型閉環傳遞函數導出及使用Matlab函數對simulink模型進行頻域分析，并在文章中給出含實現程序。

繼續訪問

?

控制教程 —— 介紹篇：4.根軌跡控制器設計

在本教程中，我們將介紹根軌跡，展示如何使用MATLAB來創建根軌跡，并演示如何通過使用根軌跡來設計滿足某些性能指標的反饋控制器。 本教程中使用的主要MATLAB命令包括：feedback,rlocus,step,controlSystemDesigner。 閉環極點 開環傳遞函數 H(s)H(s)H(s) 的根軌跡通常是在比例增益 KKK 在0到 ∞\infty∞ 變化時，形成的閉環極點的軌跡曲線...

繼續訪問

?

根軌跡和頻率響應

首先我們來了解一下根的定義，在一個閉環一階系統中，存在過度函數G(s)為s的一個式子，那么它可能會存在零點和極點，說到極點想必大家都非常熟悉了，在此，我們可以理解為“根”=“極點”。根軌跡的畫法呢我簡單提一下，根軌跡是有開環極點指向開環零點，從左向右，兩兩對應，如果缺少對應的，則以無窮極點/零點代替（舉個例子，假如只有一個極點，沒有零點，那么根軌跡就是由這個極點指向負無窮），另外，根軌跡是對稱于實軸的，其匯合點和分離點并非重點，感興趣的同學可以自己搜索一下了解一下。最終可由增益的取值范圍判斷系統的穩定性。.

繼續訪問

?

根軌跡和系統參數的確定

1、根軌跡 前面有講到通過閉環傳遞函數的極點分布情況來判斷系統是否穩定。當然還有些更簡單的判別方式，例如：勞斯穩定性判據、赫爾維茨穩定性判據等。但都是判斷系統是否穩定的，那么怎么判斷系統的穩定程度（穩定裕度）呢？或者說當一個系統參數 ...

繼續訪問

?

matlab閉環傳函的根軌跡,自動控制系統的設計--基于根軌跡的串聯校正設計

與頻域法相似，利用根軌跡法進行系統的設計也有兩種方法：1)常規方法；2)Matlab方法。Matlab的根軌跡方法允許進行可視化設計，具有操作簡單、界面直觀、交互性好、設計效率高等優點。目前常用的Matlab設計方法有：1)直接編程法；2)Matlab控制工具箱提供的強大的Rltool工具；3)第三方提供的應用程序，如CTRLLAB等。本節在給出根軌跡的設計思路的基礎上，將重點介紹第一、二種方法。...

繼續訪問

?

20200518 如何快速畫出閉環特征方程的根軌跡

Q: 什么是根軌跡法？ A: 給一個閉環的特征方程，隨著某一個參數變化，閉環特征方程的根（即閉環傳遞函數的極點）不斷變化，描述根的變化軌跡的圖叫做根軌跡圖。 Q: 針對的是開環系統還是閉環系統？ A: 利用開環系統的零極點研究閉環系統的極點（根）。 Q: 開環傳遞函數和閉環傳遞函數的區別？ A: 閉環傳遞函數是G1+GH\frac{G}{1+GH}1+GHG，開環傳遞函數是GHGHGH。 Q: 如何快速近似畫出根軌跡？ A: 首先介紹不著名的異性相吸理論（瞎編的）。 ......

繼續訪問

?

繪制課本中的根軌跡圖與零極點分布圖

《信號與系統》第三版下冊-鄭君里 例11-8 已知反饋系統結構如圖11-21所示，試繪制其根軌跡圖。 這個圖繪制的是A(s)F(s)的根軌跡圖，并不是整個閉環系統的根軌跡圖，也不是A(s)的根軌跡圖 這道題的解析部分其實是為了計算在橫軸上的交匯點。 ---------------------------------------------------------------------------------------------------------------------

繼續訪問

?

應用根軌跡分析系統性能

應用根軌跡分析系統性能 本節通過幾個實例簡要介紹根軌跡方法在分析和設計系統中的應用。 5.3.1 單參數設計 例 5.4: 已知系統的方框圖如下： 試通過根軌跡方法確定合適的反饋系數 k ，使得系統具有阻尼比為 0.4 的閉環共軛復數極點。 解：由方框圖可得系統的開環傳遞函數為：

繼續訪問

根軌跡分析

應用MATLAB進行根軌跡分析

繼續訪問

?

matlab閉環傳函的根軌跡,開環傳遞函數的跟軌跡與虛軸的交點怎么算

大學自動控制原理,已知開環傳遞函數求閉環根軌跡圖中的一個步驟不懂計算(求根軌跡與虛軸的交點)一個復數等于0,結果是實部等于0虛部等于0,這個太簡單了吧再問：詳細點還是不懂再答：-w^3j-6w^2+9wj+k=0，(-w^3+9w)j+(-6w^2+k)=0，得-w^3+9w=0，-6w^2如何matlab畫開環傳遞函數的奈奎斯特圖用MATLAB做出奈奎斯特曲線圖%k=10k=10;d=conv(...

繼續訪問

【自動控制原理】 根軌跡法之根軌跡法分析系統性能

本文主要講述了使用根軌跡法分析系統穩定性的原理，以及根據根軌跡設計參數Kg的方法步驟。最后給出了主導極點、偶極子對和開環零點對系統性能的影響

繼續訪問

?

matlab求系統根軌跡和系統增益,《自動控制原理》實驗報告(線性系統的根軌跡)...

實驗四線性系統的根軌跡一、實驗目的1.熟悉 MATLAB 用于控制系統中的一些基本編程語句和格式。2.利用 MATLAB 語句繪制系統的根軌跡。3.掌握用根軌跡分析系統性能的圖解方法。4.掌握系統參數變化對特征根位置的影響。基礎知識及 MATLAB函數根軌跡是指系統的某一參數從零變到無窮大時，特征方程的根在 s 平面上的變化軌跡。這個參數一般選為開環系統的增益 K 。課本中介紹的手工繪制根軌跡的方...

繼續訪問

最新發布 817自動控制原理-1-開環傳遞函數與閉環傳遞函數

首先，開環傳遞函數是針對閉環系統而言的，而不是指開環系統的傳遞函數。eg.輸入作用下的開環傳遞函數：G（s）=G1H2H3/（1-G2H1）輸入作用下的誤差傳遞函數：R(s)/E(s)=（1-G2H2）/（1-G2H2+G1G2H3）

繼續訪問

熱門推薦 【自控原理】第四章 根軌跡法

文章目錄A 根軌跡法的基本概念B 根軌跡方程C 繪制根軌跡的法則C.a 根軌跡法則介紹C.b 根軌跡法則（常規根軌跡）D 利用根軌跡分析系統的方法 引言 閉環控制系統的穩定性和性能指標主要由閉環系統的極點在復數平面上的位置決定。 分析和設計系統時確定閉環極點（即特征根）在復平 面的位置是十分有意義的: 閉環系統的極點在復平面的位置決定了系統的穩 定性 系統的性能指標也主要由閉環極點的位置決定 ...

繼續訪問

?

matlab-自控原理 rlocus 根軌跡 根據傳遞函數畫圖

2019獨角獸企業重金招聘Python工程師標準 ...

繼續訪問

其他

?寫評論

?

評論

?

1

?

點贊

?

踩

?

分享

前往CSDN APP閱讀全文

閱讀體驗更佳

?

CSDN

成就一億技術人

前往

?

夸克瀏覽器

根軌跡的概念

開環系統某一參數從零變換到無窮，閉環系統特征方程式的根在s平面上變化的軌跡。其中某一參數主要是指根軌跡增益，當然也可以是系統中其他的實參數。

根軌跡方程

?

將上式寫為相角及模值條件，根據這兩個條件可以完全確定s平面上的根軌跡和根軌跡上的K*值。

?

根軌跡與系統性能

1 穩定性

當參數由零變化到無窮時，根軌跡不會越過虛軸進入s右半平面則說明系統對于所有的K值都是穩定的，如果根軌跡越過虛軸進入s右半平面，則系統進入不穩定的狀態。

2穩態特性

一般情況下，根軌跡圖上標注的參數不是開環增益而是根軌跡增益，根軌跡增益與穩態誤差系數之間僅相差一個比例常數，

3動態特性

當所有閉環極點都位于實軸上時，系統為過阻尼系統；

當極點重合時，系統為臨界阻尼系統；

當閉環極點為共軛復數極點，系統為欠阻尼系統，單位階躍響應是衰減振蕩過程，且超調量將隨著K值的增大而增大。

確定閉環系統的零極點

當根軌跡增益確定時，傳遞函數也同時確定下來了，那么閉環系統的零極點位置就在根軌跡上確定下來了，通過位置可以判斷系統的穩定性能。

打開CSDN，閱讀體驗更佳

matlab求系統根軌跡和系統增益,控制系統的根軌跡分析

一、根軌跡分析方法的概念所謂根軌跡是指，當開環系統某一參數從零變到無窮大時，閉環系統特征方程的根在s平面上的軌跡。一般來說，這一參數選作開環系統的增益K，而在無零極點對消時，閉環系統特征方程的根就是閉環傳遞函數的極點。根軌跡分析方法是分析和設計線性定常控制系統的圖解方法，使用十分簡便。利用它可以對系統進行各種性能分析，1．穩定性當開環增益K從零到無窮大變化時，圖中的根軌跡不會越過虛軸進入右半s平面...

繼續訪問

【自動控制原理】根軌跡Root Locus-筆記

重點掌握根的變化規律。從而設計控制器/補償器。“根”——“極點”（一樣的概念）一階系統比如這個系統傳遞函數為，對這個系統施加一個沖擊u(t)=，的Laplace變換=1。所以系統的輸出為，令s+a=0，得“根”P=-a進行Laplace的逆變換，得到這個系統的時間函數，這里的-a就是它的根當a0時，它在時間軸上的表現為指數衰減對于一般的一階系統來說，如果把它的根在復平面上(橫軸為實數,豎軸為虛數)表達出來的話，它一定落在實軸上，如圖一階函數的。...

繼續訪問

?

一階系統開環傳遞函數表達式_古典控制理論（三）根軌跡法（閉環系統）

1 根軌跡與系統性能（1）定義：指系統某一參數從零變化到無窮大時，閉環系統特征方程式的根（閉環極點）在s平面上變化的軌跡。 Matlab命令：rlocus(sys)，默認變化參數為開環傳遞函數的增益k。（2）功能：根軌跡可以直接給出閉環系統時間相應的全部信息，而且可以指明開環零、極點應該如何變化才能滿足給定的閉環系統的性能指標要求。 根軌跡方法可以求解高階代數方程的根，實際上就是解決閉環特征方程...

繼續訪問

傳遞函數根軌跡

根軌跡 以及時域響應，自動控制，各個方面的自動控制都有用，直接出根軌跡

Simulink模型閉環傳遞函數導出及Matlab對simulink模型進行頻域分析(含實現程序)

Simulink模型閉環傳遞函數導出及使用Matlab函數對simulink模型進行頻域分析，并在文章中給出含實現程序。

繼續訪問

?

控制教程 —— 介紹篇：4.根軌跡控制器設計

在本教程中，我們將介紹根軌跡，展示如何使用MATLAB來創建根軌跡，并演示如何通過使用根軌跡來設計滿足某些性能指標的反饋控制器。 本教程中使用的主要MATLAB命令包括：feedback,rlocus,step,controlSystemDesigner。 閉環極點 開環傳遞函數 H(s)H(s)H(s) 的根軌跡通常是在比例增益 KKK 在0到 ∞\infty∞ 變化時，形成的閉環極點的軌跡曲線...

繼續訪問

?

根軌跡和頻率響應

首先我們來了解一下根的定義，在一個閉環一階系統中，存在過度函數G(s)為s的一個式子，那么它可能會存在零點和極點，說到極點想必大家都非常熟悉了，在此，我們可以理解為“根”=“極點”。根軌跡的畫法呢我簡單提一下，根軌跡是有開環極點指向開環零點，從左向右，兩兩對應，如果缺少對應的，則以無窮極點/零點代替（舉個例子，假如只有一個極點，沒有零點，那么根軌跡就是由這個極點指向負無窮），另外，根軌跡是對稱于實軸的，其匯合點和分離點并非重點，感興趣的同學可以自己搜索一下了解一下。最終可由增益的取值范圍判斷系統的穩定性。.

繼續訪問

?

根軌跡和系統參數的確定

1、根軌跡 前面有講到通過閉環傳遞函數的極點分布情況來判斷系統是否穩定。當然還有些更簡單的判別方式，例如：勞斯穩定性判據、赫爾維茨穩定性判據等。但都是判斷系統是否穩定的，那么怎么判斷系統的穩定程度（穩定裕度）呢？或者說當一個系統參數 ...

繼續訪問

?

matlab閉環傳函的根軌跡,自動控制系統的設計--基于根軌跡的串聯校正設計

與頻域法相似，利用根軌跡法進行系統的設計也有兩種方法：1)常規方法；2)Matlab方法。Matlab的根軌跡方法允許進行可視化設計，具有操作簡單、界面直觀、交互性好、設計效率高等優點。目前常用的Matlab設計方法有：1)直接編程法；2)Matlab控制工具箱提供的強大的Rltool工具；3)第三方提供的應用程序，如CTRLLAB等。本節在給出根軌跡的設計思路的基礎上，將重點介紹第一、二種方法。...

繼續訪問

?

20200518 如何快速畫出閉環特征方程的根軌跡

Q: 什么是根軌跡法？ A: 給一個閉環的特征方程，隨著某一個參數變化，閉環特征方程的根（即閉環傳遞函數的極點）不斷變化，描述根的變化軌跡的圖叫做根軌跡圖。 Q: 針對的是開環系統還是閉環系統？ A: 利用開環系統的零極點研究閉環系統的極點（根）。 Q: 開環傳遞函數和閉環傳遞函數的區別？ A: 閉環傳遞函數是G1+GH\frac{G}{1+GH}1+GHG，開環傳遞函數是GHGHGH。 Q: 如何快速近似畫出根軌跡？ A: 首先介紹不著名的異性相吸理論（瞎編的）。 ......

繼續訪問

?

繪制課本中的根軌跡圖與零極點分布圖

《信號與系統》第三版下冊-鄭君里 例11-8 已知反饋系統結構如圖11-21所示，試繪制其根軌跡圖。 這個圖繪制的是A(s)F(s)的根軌跡圖，并不是整個閉環系統的根軌跡圖，也不是A(s)的根軌跡圖 這道題的解析部分其實是為了計算在橫軸上的交匯點。 ---------------------------------------------------------------------------------------------------------------------

繼續訪問

?

應用根軌跡分析系統性能

應用根軌跡分析系統性能 本節通過幾個實例簡要介紹根軌跡方法在分析和設計系統中的應用。 5.3.1 單參數設計 例 5.4: 已知系統的方框圖如下： 試通過根軌跡方法確定合適的反饋系數 k ，使得系統具有阻尼比為 0.4 的閉環共軛復數極點。 解：由方框圖可得系統的開環傳遞函數為：

繼續訪問

根軌跡分析

應用MATLAB進行根軌跡分析

繼續訪問

?

matlab閉環傳函的根軌跡,開環傳遞函數的跟軌跡與虛軸的交點怎么算

大學自動控制原理,已知開環傳遞函數求閉環根軌跡圖中的一個步驟不懂計算(求根軌跡與虛軸的交點)一個復數等于0,結果是實部等于0虛部等于0,這個太簡單了吧再問：詳細點還是不懂再答：-w^3j-6w^2+9wj+k=0，(-w^3+9w)j+(-6w^2+k)=0，得-w^3+9w=0，-6w^2如何matlab畫開環傳遞函數的奈奎斯特圖用MATLAB做出奈奎斯特曲線圖%k=10k=10;d=conv(...

繼續訪問

【自動控制原理】 根軌跡法之根軌跡法分析系統性能

本文主要講述了使用根軌跡法分析系統穩定性的原理，以及根據根軌跡設計參數Kg的方法步驟。最后給出了主導極點、偶極子對和開環零點對系統性能的影響

繼續訪問

?

matlab求系統根軌跡和系統增益,《自動控制原理》實驗報告(線性系統的根軌跡)...

實驗四線性系統的根軌跡一、實驗目的1.熟悉 MATLAB 用于控制系統中的一些基本編程語句和格式。2.利用 MATLAB 語句繪制系統的根軌跡。3.掌握用根軌跡分析系統性能的圖解方法。4.掌握系統參數變化對特征根位置的影響。基礎知識及 MATLAB函數根軌跡是指系統的某一參數從零變到無窮大時，特征方程的根在 s 平面上的變化軌跡。這個參數一般選為開環系統的增益 K 。課本中介紹的手工繪制根軌跡的方...

繼續訪問

最新發布 817自動控制原理-1-開環傳遞函數與閉環傳遞函數

首先，開環傳遞函數是針對閉環系統而言的，而不是指開環系統的傳遞函數。eg.輸入作用下的開環傳遞函數：G（s）=G1H2H3/（1-G2H1）輸入作用下的誤差傳遞函數：R(s)/E(s)=（1-G2H2）/（1-G2H2+G1G2H3）

繼續訪問

熱門推薦 【自控原理】第四章 根軌跡法

文章目錄A 根軌跡法的基本概念B 根軌跡方程C 繪制根軌跡的法則C.a 根軌跡法則介紹C.b 根軌跡法則（常規根軌跡）D 利用根軌跡分析系統的方法 引言 閉環控制系統的穩定性和性能指標主要由閉環系統的極點在復數平面上的位置決定。 分析和設計系統時確定閉環極點（即特征根）在復平 面的位置是十分有意義的: 閉環系統的極點在復平面的位置決定了系統的穩 定性 系統的性能指標也主要由閉環極點的位置決定 ...

繼續訪問

?

matlab-自控原理 rlocus 根軌跡 根據傳遞函數畫圖

2019獨角獸企業重金招聘Python工程師標準 ...

繼續訪問

其他

?寫評論

?

評論

?

1

?

點贊

?

踩

?

分享

前往CSDN APP閱讀全文

閱讀體驗更佳

?

CSDN

成就一億技術人

前往

?

夸克瀏覽器

python如何傳遞給c++一個結構體指針？前提是swig封裝的C++函數，請寫出代

在封裝的代碼間傳遞指針你要確保他們運行在相同的地址空間里，還要保證指針指向的內存的生存期是安全的，否則這種思路就是錯誤的。實現方法舉例如下：

1、定義了C

結構體和函數如下

typedef

struct

NameAge

{

char

name[20];

int

age;

}NameAge

,

*NameAgePointer;

void

test(NameAgePointer

p)

//

接收結構體指針

{

//

do

something

with

p...

}

2、python定義結構體如下

#python中結構體定義

class

PyStruct():

def

__init__(self,

name,

age):

self.name

=

name

self.age

=

age

fred

=

PyStruct("fred",

5)

3、假設把第1步里的test封裝成example模塊，python導入example（既然你都會swig了，這個過程就不啰嗦了）

import

example

example.test(pointer(fred))

以上是基本思路，因為搭建開發環境和過程比較繁雜，沒有驗證過，但是應該沒有大問題

如何用Python編寫一個素數環

此文主要目的，是向大家展示如何才能用python語言，來部署STARK算法。

STARKs（可擴容的透明知識論證）是創建一種證明的技術，這項證明中f(x)=y，其中f可能要花很長的時間來進行計算，但是這個證明可以被很快驗證。STARK是“雙重擴容”：對于一個需要t步驟的計算，這會花費大約O(t * log(t))步驟才能完成這個證明，這可能是最優的情況，而且這需要通過~O(log2(t))個步驟才能驗證，對于中等大小的T值，它比原始計算快得多。STARKs也擁有隱私保護的“零知識證明”的特性，雖然我們將這類使用案例應用到其中，從而完成可驗證的延遲功能，不需要這類性質，所以我們不用擔心。

首先，先請幾項說明：

這個代碼還沒有完全審核；在實際使用案例中的情況，還不能保證

這部分代碼是還沒有達到理想狀態（是用Python語言寫的）

STARKs 的“真實情況” 傾向于使用二進制字段而不是素數域的特定應用程序效率的原因；但是，他們確實也表現出，這里寫出的代碼是合法并且可用的。

沒有一個真實的方法來使用STARK。它是一個非常寬泛的加密和數學架構，同時為不同的應用有不同的設置，以及連續的研究來減少證明者和驗證者的復雜性，同時提高可用性。

此文希望大家能夠知道，模運算和素數域是如何運行的，

并且和多項式概念，插值和估值進行結合。

現在，讓我們一起來了解吧！

MIMC

下面是STARK的功能展示：

def mimc(inp, steps, round_constants): start_time = time.time() for i in range(steps-1): inp = (inp**3 + round_constants[i % len(round_constants)]) % modulus print("MIMC computed in %.4f sec" % (time.time() - start_time)) return inp

我們選擇MIMC作為案例，因為它（i）很容易理解，（ii）在真實世界使用的很多。函數功能見下圖：

注意：在很多關于MIMC的討論中，你可以典型地看出使用了XOR，而不是+；這是因為MIMC可以在二進制情況下使用，其中添加是XOR；這里我們會在素數領域進行。

在我們的案例中，常數相對而言會是比較小的列表（例如，64位），這會一直連續地進行周期循環（也就說，在k[64]之后）。MIMC自身可以獲得這個特性，因為MIMC可以向后進行計算（從相應的輸出獲得輸入），但是往后計算需要比向前計算多花費100倍的時間（并且沒有方向可以同步進行）。所以你可以將往后計算的功能想象成計算不能同步的工作量證明，并且往前方向計算的功能可以作為驗證的過程。

x - x(2p-1)/3 是x - x3 的反函數；根據費馬小定理，這是真實的，盡管這個定理沒有費馬大定理出名，但是依然對數學的貢獻很大。

我們嘗試使用STARK來進行更加有效的驗證，而不是讓驗證者必須在向前方向運行MIMC，在完成向后計算之后，證明者可以在向前方向進行STARK計算，并且驗證者可以很簡單地驗證STARK。我們希望計算STARK可以比MIMC向前和向后之間的運行速度差別要小，所以證明者的時間仍然是有初始的向后計算來主導的。而并不是STARK計算。STARK的認證會相對較快（在python語言算法中，可以是0.05-0.3秒），不論初始的計算時間有多長。

所有的計算會在2256 – 351 * 232 + 1個模內完成；我們使用素數模，因為它是小于2256 最大的素數，其中乘法群包含了232 個子集（也就是說，有這樣一個數g，從而在完全232次循環之后，G素數環的連續冪模繞回到1），而且是按照6k+5的形式。首個特性是保證FFT和FRI算法的有效版本，其次是保證MIMC實際上可以向后計算（請見上面提到的x - x(2p-1)/3 使用方法）。

素域操作

我們通過建立方便的等級來進行素域的操作，同時也有多項式的操作。代碼如下，收首先是小數位數：

class PrimeField(): def __init__(self, modulus): # Quick primality test assert pow(2, modulus, modulus) == 2 self.modulus = modulus def add(self, x, y): return (x+y) % self.modulus def sub(self, x, y): return (x-y) % self.modulus def mul(self, x, y): return (x*y) % self.modulus

并且使用擴展歐幾里得算法，來計算模塊逆轉（這和在素域中計算1/x相同）：

# Modular inverse using the extended Euclidean algorithm def inv(self, a): if a == 0: return 0 lm, hm = 1, 0 low, high = a % self.modulus, self.modulus while low 1: r = high//low nm, new = hm-lm*r, high-low*r lm, low, hm, high = nm, new, lm, low return lm % self.modulus

上面的算法是相對昂貴的；幸運地是，對于特定的案例，我們需要做很多的模逆計算，有一個數學方法可以讓我們來計算很多逆運算，被稱為蒙哥馬利批量求逆：

使用蒙哥馬利批量求逆來計算模逆，其輸入為紫色，輸出為綠色，乘法門為黑色，紅色方塊是唯一的模逆。

下面的代碼是算法的體現，其中包含一些特別的邏輯。如果我們正在求逆的集合中包含零，那么它會將這些零的逆設置為 0 并繼續前進。

def multi_inv(self, values): partials = [1] for i in range(len(values)): partials.append(self.mul(partials[-1], values[i] or 1)) inv = self.inv(partials[-1]) outputs = [0] * len(values) for i in range(len(values), 0, -1): outputs[i-1] = self.mul(partials[i-1], inv) if values[i-1] else 0 inv = self.mul(inv, values[i-1] or 1) return outputs

這部分算法接下來會驗證稱為非常重要的東西，特別是當我們開始和不同階的多項式進行計算的時候。

現在我們來看看一些多項式計算。我們把多項式當做一個數據集，其中的i是第i階（例如，x3 + 2x + 1變成[1, 2, 0, 1]）。下面就是在一個點進行多項式估算的方法：

# Evaluate a polynomial at a point def eval_poly_at(self, p, x): y = 0 power_of_x = 1 for i, p_coeff in enumerate(p): y += power_of_x * p_coeff power_of_x = (power_of_x * x) % self.modulus return y % self.modulus

困難和挑戰

f.eval_poly_at([4, 5, 6], 2)的輸出是多少？模是31嗎？

下面的解釋就是答案

.其實也有代碼是多項式加法，減法，乘法和除法；這是很長的加減乘除運算。有一個很重要的內容是拉格朗日插值，它將一組 x 和 y 坐標作為輸入，并返回通過所有這些點的最小多項式（你可以將其視為多項式求值的逆）：

# Build a polynomial that returns 0 at all specified xs def zpoly(self, xs): root = [1] for x in xs: root.insert(0, 0) for j in range(len(root)-1): root[j] -= root[j+1] * x return [x % self.modulus for x in root] def lagrange_interp(self, xs, ys): # Generate master numerator polynomial, eg. (x - x1) * (x - x2) * ... * (x - xn) root = self.zpoly(xs) # Generate per-value numerator polynomials, eg. for x=x2, # (x - x1) * (x - x3) * ... * (x - xn), by dividing the master # polynomial back by each x coordinate nums = [self.div_polys(root, [-x, 1]) for x in xs] # Generate denominators by evaluating numerator polys at each x denoms = [self.eval_poly_at(nums[i], xs[i]) for i in range(len(xs))] invdenoms = self.multi_inv(denoms) # Generate output polynomial, which is the sum of the per-value numerator # polynomials rescaled to have the right y values b = [0 for y in ys] for i in range(len(xs)): yslice = self.mul(ys[i], invdenoms[i]) for j in range(len(ys)): if nums[i][j] and ys[i]: b[j] += nums[i][j] * yslice return [x % self.modulus for x in b]

相關數學知識請參見此文的M-N部分。需要注意，我們也會有特別的方法lagrange_interp_4和lagrange_interp_2來加速次數小于 2 的拉格朗日插值和次數小于 4 的多項式運算。

快速傅立葉變換

如果你仔細閱讀上面的算法，你也許會發現拉格朗日插值和多點求值（即求在N個點處次數小于N的多項式的值）都需要耗費2次時間，例如對于1000個點求拉格朗日插值，需要幾百萬個步驟，而且100萬個點的拉格朗日插值需要萬億個步驟。這是不可接受的低效率，所以我們需要使用更加有效的算法，快速傅立葉變換。

FFT只需要花費O(n * log(n))的時間（也就是說，1000個點的計算需要10,000步，100萬個點的計算需要2000步），雖然它的范圍更受限制；x坐標必須是單位根部的完全集合，必須滿足N = 2k 階。也就是說，如果有N個點，那么x坐標必須某個P值的連續冪，1, p, p2, p3…，其中pN = 1。這個算法能夠用來進行多點計算和插值計算，而且只需要調整一個小參數。

下面就是算法詳情（這是個簡單的表達方式；更詳細內容可以參閱此處代碼）

def fft(vals, modulus, root_of_unity): if len(vals) == 1: return vals L = fft(vals[::2], modulus, pow(root_of_unity, 2, modulus)) R = fft(vals[1::2], modulus, pow(root_of_unity, 2, modulus)) o = [0 for i in vals] for i, (x, y) in enumerate(zip(L, R)): y_times_root = y*pow(root_of_unity, i, modulus) o[i] = (x+y_times_root) % modulus o[i+len(L)] = (x-y_times_root) % modulus return o def inv_fft(vals, modulus, root_of_unity): f = PrimeField(modulus) # Inverse FFT invlen = f.inv(len(vals)) return [(x*invlen) % modulus for x in fft(vals, modulus, f.inv(root_of_unity))]

你可以自己通過一些輸入來運行代碼，并且看看是否能得到想要的結果，當你使用eval_poly_at的時候，給出你期望得到的答案。例如：

fft.fft([3,1,4,1,5,9,2,6], 337, 85, inv=True) [46, 169, 29, 149, 126, 262, 140, 93] f = poly_utils.PrimeField(337) [f.eval_poly_at([46, 169, 29, 149, 126, 262, 140, 93], f.exp(85, i)) for i in range(8)] [3, 1, 4, 1, 5, 9, 2, 6]

傅里葉變換會把[x[0] …. x[n-1]]作為輸入，并且它的目標是輸出x[0] + x[1] + … + x[n-1]作為首個元素，x[0] + x[1] * 2 + … + x[n-1] * w**(n-1)作為第二個元素，等等；快速傅里葉變換可以通過把數據分為兩半，來完成這個，在兩邊都進行FFT，然后將結果結合在一起。

上圖就是信息如何進行FFT運算的解釋。請注意FFT是如何進行兩次數據復制，并且進行粘合，直到你得到一個元素。

現在，我們把所有部分組合起來，看看整件事情是如何：def mk_mimc_proof(inp, steps, round_constants)，它生成運行 MIMC 函數的執行結果的證明，其中給定的輸入為步驟數。首先，是一些 assert 函數：

# Calculate the set of x coordinates xs = get_power_cycle(root_of_unity, modulus) column = [] for i in range(len(xs)//4): x_poly = f.lagrange_interp_4( [xs[i+len(xs)*j//4] for j in range(4)], [values[i+len(values)*j//4] for j in range(4)], ) column.append(f.eval_poly_at(x_poly, special_x))

擴展因子是我們將要拉伸的計算軌跡（執行 MIMC 函數的“中間值”的集合）。

m2 = merkelize(column) # Pseudo-randomly select y indices to sample # (m2[1] is the Merkle root of the column) ys = get_pseudorandom_indices(m2[1], len(column), 40) # Compute the Merkle branches for the values in the polynomial and the column branches = [] for y in ys: branches.append([mk_branch(m2, y)] + [mk_branch(m, y + (len(xs) // 4) * j) for j in range(4)])

我們需要步數乘以擴展因子最多為 2^32，因為當 k 32 時，我們沒有 2^k 次的單位根。

computational_trace_polynomial = inv_fft(computational_trace, modulus, subroot) p_evaluations = fft(computational_trace_polynomial, modulus, root_of_unity)

我們首個計算會是得出計算軌跡；也就是說，所有的計算中間值，從輸入到輸出。

assert steps = 2**32 // extension_factor assert is_a_power_of_2(steps) and is_a_power_of_2(len(round_constants)) assert len(round_constants) steps

然后，我們會從將計算軌跡轉換為多項式，在單位根 g （其中，g^steps = 1）的連續冪的軌跡上“放下”連續值，然后我們對更大的集合——即單位根 g2 的連續冪，其中 g2^steps * 8 = 1（注意 g2^8 = g）的多項式求值。

# Generate the computational trace computational_trace = [inp] for i in range(steps-1): computational_trace.append((computational_trace[-1]**3 + round_constants[i % len(round_constants)]) % modulus) output = computational_trace[-1]

黑色： g1 的冪。紫色： g2 的冪。橙色：1。你可以將連續的單位根看作一個按這種方式排列的圓圈。我們沿著 g1的冪“放置”計算軌跡，然后擴展它來計算在中間值處（即 g2 的冪）的相同多項式的值。

我們可以將MIMC的循環常數轉換為多項式。因為這些循環常數鏈是非常通常發生地（在我們的測試中，每64個步驟都會進行），最終證明他們形成了64階的多項式，而且外面可以很容易計算出它的表達式，以及擴展式：

skips2 = steps // len(round_constants) constants_mini_polynomial = fft(round_constants, modulus, f.exp(subroot, skips2), inv=True) constants_polynomial = [0 if i % skips2 else constants_mini_polynomial[i//skips2] for i in range(steps)] constants_mini_extension = fft(constants_mini_polynomial, modulus, f.exp(root_of_unity, skips2))

假設其中有8192個步驟，并且有64個循環常數。這是我們想要做的：我們正在進行FFT，從而計算循環常數來作為g1128 的功能。然后我們在之間加入很多零，來完成g1本身的功能。因為g1128 大約每64步進行循環，我們知道g1這個功能也會同樣。我們只計算這個擴展中的512個步驟，因為我們知道這個擴展會在每512步之后重復。現在，我們按照斐波那契案例中那樣，計算C(P(x))，除了這次是計算，需要注意，我們不在計算使用系數形式的多項式；而是根據高次單位根的連續冪來對多項式進行求值。

c_of_p需要滿足Q(x) = C(P(x), P(g1*x)，K(x)) = P(g1*x) – P(x)**3 – K(x)；目標是對于任何我們放入計算軌道的x（除了最后一步，因為在最后一步之后，就沒有步驟），計算軌跡中的下個數值就和之前的相等，再加上循環常量。與第1部分中的斐波那契示例不同，其中如果某個計算步驟是在k向量，下個就會是k+1向量，我們把低次單位根（ g1 ）的連續冪放下計算軌跡，所以如果某個計算步驟是在x = g1i ，下個步驟就會在g1i+1 = g1i * g1 = x * g1。因此，對于低階單位根（ g1 ）的每一個冪，我們希望最終會是P(x*g1) = P(x)**3 + K(x)，或者P(x*g1) – P(x)**3 – K(x) = Q(x) = 0。因此，Q(x) 會在低次單位根 g 的所有連續冪上等于零（除了最后一個）。

# Create the composed polynomial such that # C(P(x), P(g1*x), K(x)) = P(g1*x) - P(x)**3 - K(x) c_of_p_evaluations = [(p_evaluations[(i+extension_factor)%precision] - f.exp(p_evaluations[i], 3) - constants_mini_extension[i % len(constants_mini_extension)]) % modulus for i in range(precision)] print('Computed C(P, K) polynomial')

有個代數定理證明，如果Q(x)在所有這些x坐標，都等于零，那么最小多項式的乘積就會在所有這些x坐標等于零：Z(x) = (x – x_1) * (x – x_2) * … * (x – x_n)。通過證明在任何單個的坐標，Q(x)是等于零，我們想要證明這個很難，因為驗證這樣的證明比運行原始計算需要耗費更長的時間，我們會使用一個間接的方式來證明Q(x)是Z(x)的乘積。并且我們會怎么做呢？通過證明D(x) = Q(x) / Z(x)，并且使用FRI來證明它其實是個多項式，而不是個分數。

我們選擇低次單位根和高次單位根的特定排列，因為事實證明，計算Z(x)，而且除以Z(x)也十分簡單：Z 的表達式是兩項的一部分。

需要注意地是，直接計算Z的分子和分母，然后使用批量模逆的方法將除以Z轉換為乘法，隨后通過 Z(X) 的逆來逐點乘以 Q(x) 的值。需要注意，對于低次單位根的冪，除了最后一個，都可以得到Z(x) = 0，所以這個計算包含其逆計算就會中斷。這是非常不幸的，雖然我們會通過簡單地修改隨機檢查和FRI算法來堵住這個漏洞，所以就算我們計算錯誤，也沒關系。

因為Z(x)可以簡潔地表達，我們也可以獲得另個好處：驗證者對于任何特別的x，可以快速計算Z(x)，而且還不需要任何提前計算。對于證明者來說，我們可以接受證明者必須處理大小等于步數的多項式，但我們不想讓驗證者做同樣的事情，因為我們希望驗證過程足夠簡潔。

# Compute D(x) = Q(x) / Z(x) # Z(x) = (x^steps - 1) / (x - x_atlast_step) z_num_evaluations = [xs[(i * steps) % precision] - 1 for i in range(precision)] z_num_inv = f.multi_inv(z_num_evaluations) z_den_evaluations = [xs[i] - last_step_position for i in range(precision)] d_evaluations = [cp * zd * zni % modulus for cp, zd, zni in zip(c_of_p_evaluations, z_den_evaluations, z_num_inv)] print('Computed D polynomial')

在幾個隨機點上，進行概念檢測D(x) * Z(x) = Q(x)，從而可以驗證轉賬約束，每個計算步驟是之前步驟的有效結果。但是我們也想驗證邊界約束，其中計算的輸入和輸出就是證明者所說的那樣。只是要求證明者提供P(1), D(1), P(last_step)還有D(last_step)的數值，這些都是很脆弱的；沒有證明，那些數值都是在同個多項式。所以，我們使用類似的多項式除法技巧：

# Compute interpolant of ((1, input), (x_atlast_step, output)) interpolant = f.lagrange_interp_2([1, last_step_position], [inp, output]) i_evaluations = [f.eval_poly_at(interpolant, x) for x in xs] zeropoly2 = f.mul_polys([-1, 1], [-last_step_position, 1]) inv_z2_evaluations = f.multi_inv([f.eval_poly_at(quotient, x) for x in xs]) # B = (P - I) / Z2 b_evaluations = [((p - i) * invq) % modulus for p, i, invq in zip(p_evaluations, i_evaluations, inv_z2_evaluations)] print('Computed B polynomial')

那么，我們的論證如下。證明者想要證明P(1) == input和P(last_step) == output。如果我們將I(x)作為插值，那么就是穿越(1, input)和(last_step, output)亮點的線，于是P(x) – I(x)就會在這亮點上等于零。因此，它會證明P(x) – I(x)是P(x) – I(x)的乘積，并且我們通過提高商數來證明這點。

紫色：計算軌跡多項式 (P) 。綠色：插值 (I)（注意插值是如何構造的，其在 x = 1 處等于輸入（應該是計算軌跡的第一步），在 x=g^(steps-1) 處等于輸出（應該是計算軌跡的最后一步）。紅色：P-I。黃色：在x = 1和 x=g^(steps-1)（即 Z2）處等于 0 的最小多項式。粉紅色：(P – I) / Z2。

現在，我們來看看將P，D和B的默克爾根部組合在一起。

現在，我們需要證明P，D和B其實都是多項式，并且是最大的正確階數。但是FRI證明是很大且昂貴的，而且我們不想有三個FRI證明，所以，我們計算 P，D 和 B 的偽隨機線性組合，并且基于它來進行FRI證明：

# Compute their Merkle roots mtree = merkelize([pval.to_bytes(32, 'big') + dval.to_bytes(32, 'big') + bval.to_bytes(32, 'big') for pval, dval, bval in zip(p_evaluations, d_evaluations, b_evaluations)]) print('Computed hash root')

除非所有這三個多項式有正確的低階，不然幾乎不可能有隨機選擇的線性組合，所以這很足夠。

我們想要證明D的階數小于2 * steps，而且P 和 B 的次數小于steps，所以我們其實使用了隨機的P, P * xsteps, B, Bsteps 和 D的隨機組合，并且可以看出這部分組合是小于2 * steps。

現在，我們來檢查下所有的多項式組合。我們先獲得很多隨機的索引，然后在這些索引上為默克爾樹枝提供多項式：

k1 = int.from_bytes(blake(mtree[1] + b'\x01'), 'big') k2 = int.from_bytes(blake(mtree[1] + b'\x02'), 'big') k3 = int.from_bytes(blake(mtree[1] + b'\x03'), 'big') k4 = int.from_bytes(blake(mtree[1] + b'\x04'), 'big') # Compute the linear combination. We don't even bother calculating it # in coefficient form; we just compute the evaluations root_of_unity_to_the_steps = f.exp(root_of_unity, steps) powers = [1] for i in range(1, precision): powers.append(powers[-1] * root_of_unity_to_the_steps % modulus) l_evaluations = [(d_evaluations[i] + p_evaluations[i] * k1 + p_evaluations[i] * k2 * powers[i] + b_evaluations[i] * k3 + b_evaluations[i] * powers[i] * k4) % modulus for i in range(precision)]

get_pseudorandom_indices函數會回復[0…precision-1]范圍中的隨機索引，而且exclude_multiples_of參數并不會給出特定參數倍數的值。這就保證了，我們不會沿著原始計算軌跡進行采樣，否則就會獲得錯誤的答案。

證明是由一組默克爾根、經過抽查的分支以及隨機線性組合的低次證明組成：

# Do some spot checks of the Merkle tree at pseudo-random coordinates, excluding # multiples of `extension_factor` branches = [] samples = spot_check_security_factor positions = get_pseudorandom_indices(l_mtree[1], precision, samples, exclude_multiples_of=extension_factor) for pos in positions: branches.append(mk_branch(mtree, pos)) branches.append(mk_branch(mtree, (pos + skips) % precision)) branches.append(mk_branch(l_mtree, pos)) print('Computed %d spot checks' % samples)

整個證明最長的部分是默克爾樹分支，還有FRI證明，這是有更多分支來組成的。這是驗證者的實質結果：

o = [mtree[1], l_mtree[1], branches, prove_low_degree(l_evaluations, root_of_unity, steps * 2, modulus, exclude_multiples_of=extension_factor)]

在每個位置，證明者需要提供一個默克爾證明，從而讓驗證者能夠檢查這個默克爾證明，并且檢查C(P(x), P(g1*x), K(x)) = Z(x) * D(x)以及B(x) * Z2(x) + I(x) = P(x)（提醒：對于不在初始計算軌道上的x，Z(x)不會是零，所以C(P(x), P(g1*x), K(x)也不會是零)。驗證者也會檢查線性組合是正確的，然后調用。

for i, pos in enumerate(positions): x = f.exp(G2, pos) x_to_the_steps = f.exp(x, steps) mbranch1 = verify_branch(m_root, pos, branches[i*3]) mbranch2 = verify_branch(m_root, (pos+skips)%precision, branches[i*3+1]) l_of_x = verify_branch(l_root, pos, branches[i*3 + 2], output_as_int=True) p_of_x = int.from_bytes(mbranch1[:32], 'big') p_of_g1x = int.from_bytes(mbranch2[:32], 'big') d_of_x = int.from_bytes(mbranch1[32:64], 'big') b_of_x = int.from_bytes(mbranch1[64:], 'big') zvalue = f.div(f.exp(x, steps) - 1, x - last_step_position) k_of_x = f.eval_poly_at(constants_mini_polynomial, f.exp(x, skips2)) # Check transition constraints Q(x) = Z(x) * D(x) assert (p_of_g1x - p_of_x ** 3 - k_of_x - zvalue * d_of_x) % modulus == 0 # Check boundary constraints B(x) * Z2(x) + I(x) = P(x) interpolant = f.lagrange_interp_2([1, last_step_position], [inp, output]) zeropoly2 = f.mul_polys([-1, 1], [-last_step_position, 1]) assert (p_of_x - b_of_x * f.eval_poly_at(zeropoly2, x) - f.eval_poly_at(interpolant, x)) % modulus == 0 # Check correctness of the linear combination assert (l_of_x - d_of_x - k1 * p_of_x - k2 * p_of_x * x_to_the_steps - k3 * b_of_x - k4 * b_of_x * x_to_the_steps) % modulus == 0

其實還沒有完成成功；證明對跨多項式檢查和 FRI 所需的抽查次數的可靠性分析是非常棘手的。但是這些就是所有代碼，至少你不用擔心進行瘋狂的優化。當我運行以上代碼的時候，我們會獲得STARK證明，會有300-400倍的證明成本例如，一個需要 0.2 秒的 MIMC 計算需要 60 秒來證明）。這就使得4核機器計算MIMC中的 STARK，實際上可以比后向計算 MIMC 更快。也就是說，在python語言，這會相對低效的實現，并且這也會證明運行時間比例會不同。同時，也值得指出，MIMC 的 STARK 證明成本非常低，因為MIMC幾乎是完美地可計算，它的數學形式很簡單。對于平均計算，會包含更少的清晰計算（例如，檢查一個數是大于還是小于另一個），其計算成本可能會更高，會有大約10000-50000倍。

網頁標題：python開環傳遞函數 開環傳遞函數怎么求閉環傳遞函數
轉載注明：http://vcdvsql.cn/article40/dosdceo.html

成都網站建設公司_創新互聯，為您提供建站公司、網頁設計公司、網站導航、企業建站、響應式網站、外貿網站建設

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯