模組:Complex Number/Calculate

模块文档[查看] [编辑] [历史] [清除缓存]

此模块被引用於約12,000個頁面。
為了避免造成大規模的影響，所有對此模块的編輯應先於沙盒或測試樣例上測試。
測試後無誤的版本可以一次性地加入此模块中，但是修改前請務必於討論頁發起討論。

模板引用數量會自動更新。

此模块使用Lua语言：

Module:Complex Number

本模組定義了一些數學運算的結構與邏輯。

使用方法

項目	語法	說明	範例
數字的表達	實數 `+或-實數值`、科學記號 `+或-實數值e+或-科學記號值`、含單位的數 `+或-實數值單位`或含常數單位 `任何數值表達式 ⋅ 常數或單位的表達式`	數字的表達可分為實數表達、科學記號和含單位的數。實數表達即一般的實數；科學記號為一實數緊接著一個 `e` 和一個整數，例如`實數值e整數值`則代表`實數值×10^整數值`；另一個表達方式為一個實數值緊接著一個複變單位或角度單位，例如`2i`表示兩倍的虛數單位。此表達式不能與科學記號一同使用。能使用的單位包括`i`、`j`、`k`、`°`和`π`。其餘需使用 `⋅` 運算子來表達。	`+2.735`→脚本错误：函数“templateCalculate”不存在。 `-2735e-3`→脚本错误：函数“templateCalculate”不存在。 `2.735i`→脚本错误：函数“templateCalculate”不存在。 `-180°`→脚本错误：函数“templateCalculate”不存在。
四則運算與冪運算	`運算式運算符運算式`	依序以中綴表示法表達運算式即可。	`2+35^2`→脚本错误：函数“templateCalculate”不存在。*
函數	`函數 ( 參數1, 參數2 ...)`	调用现有函数。所有函數都至少要傳入一個參數。	`factorial(5)`→脚本错误：函数“templateCalculate”不存在。
多組運算	`運算式1 ; 運算式2`	僅會顯示最後一組運算的結果	`2+3;23`→脚本错误：函数“templateCalculate”不存在。*
變數定義	`變數名稱 ← 運算式`	給特定名稱的變數賦值。需特別注意所有變數的範圍（Scope）皆相同（可想像所有變數皆為全域變數），包括函數中的參數，因此若函數外層已經定義了變數x則函數內部需避免使用同名變數x。	`x←5;x`→脚本错误：函数“templateCalculate”不存在。
函數定義	`函數名稱 : 參數1, 參數2 ...↦ 函數運算式 ;`	函數的語法為以名稱起始並以冒號區隔函數名稱與定義（函數名稱可留空，但冒號不能省去），整個語法要以分號（`;`）結尾。位於映射符號（`↦`）前方為函數的變數或參數，後方為函數主體定義，即 $f : x \mapsto f (x);$ 。函數可以有多個變數，但僅能有單個輸出，即 $\mathbb {C} ^{n}\mapsto \mathbb {C}$ 或 $\mathbb {R} ^{n}\mapsto \mathbb {R}$ 。同時函數語法不建議寫成嵌套結構，即不建議將函數定義內包含另一個函數的定義，但可以分開定義再行組合；此外，函數定義內不能包含分號，因為分號會視為函數的結尾。	`f:x↦x^2+1;(0);f(5)` →脚本错误：函数“templateCalculate”不存在。
運算符優先序調整	`(運算式要優先計算的運算符運算式) 運算符運算式`	使用括號來令特定運算優先進行。	`2+35`→脚本错误：函数“templateCalculate”不存在。* `( 2+3 ) 5`→脚本错误：函数“templateCalculate”不存在。*

運算符

語法	名稱	元數	說明	優先	範例	效果	math輸出
z基礎算术
a `e`	a 科學記號	2	a 當e左鄰一實數、右鄰一整數時，則為科學記號，以`256e-3`為例，其代表的結果為 $256\times 10^{-3}$ 。要注意的是左邊的數必為單一實數、右邊的數必為整數，可為負數，且中間不能有空格。	a999∞	a `12.3e4`	a	a
a `()`	a 括弧	1	a 改變運算優先順序	a999∞	a `2*(2+3)`	a 10	a
z布尔代数
a `and`	a 邏輯且	2	a 邏輯且的字母模式。使用時須與前後文各間隔至少一個空格	a5	a `(1=1) and (1=2)`	a	a
a `nand`	a 邏輯與非	2	a 邏輯與非的字母模式。使用時須與前後文各間隔至少一個空格	a5	a `(1=1) nand (1=2)`	a	a
a `or`	a 邏輯或	2	a 邏輯或的字母模式。使用時須與前後文各間隔至少一個空格	a4	a `(1=1) or (1=2)`	a	a
a `nor`	a 邏輯或非	2	a 邏輯或非的字母模式。使用時須與前後文各間隔至少一個空格	a4	a `(1=1) nor (1=2)`	a	a
a `xor`	a 邏輯異或	2	a 邏輯異或的字母模式。使用時須與前後文各間隔至少一個空格	a4	a `(1=1) xor (1=2)`	a	a
a `xnor`	a 邏輯若且唯若	2	a 邏輯若且唯若的字母模式。使用時須與前後文各間隔至少一個空格	a4	a `(1=1) xnor (1=2)`	a	a
a `not`	a 邏輯非	1	a 邏輯非的字母模式。使用時須與前後文各間隔至少一個空格	a13	a `not (1=2)`	a	a
z数值修约
a `round`	a 数值修约	2	a round 的運算子模式，會將一數四捨五入到指定的位數。使用時須與前後文各間隔至少一個空格	a8	a `π round 6`	a	a
z複變
a `i`	a 虛數單位	1	a 表達純虛數	a999∞	a `3i`	a 3i	a
z技術性
a `return`	a 返回值	1	a 返回數值。需注意return後方必須跟著一個數值或表達式，否則會變成未定義行為而出現預期外的結果。	a2	a `return 7;8`	a	a
z三角函数
a `°`	a 角度單位	1	a 用於表示角度單位的符號。	a10	a `180°`	a	a
a `π`	a 圓周率	1	a 表示圓周率。	a10	a `3π`	a	a

註：另有>=、<=、==（相等判斷）、~=（不相等判斷）、!=（不相等判斷）、@=（數值指派）、+=（相加指派）、-=（相減指派）、*=（相乘指派）、/=（相除指派）、^=（冪指派）、&=（邏輯與指派）、|=（邏輯或指派）可供使用，其會自動替換為上表中對應的運算元。指派運算元須注意等號左邊必須是一個單一變數詞語，不可以是括弧或函數變換的結果。

常數和數值

語法	名稱	別名	說明	數值
`e`	自然底數		自然對數函數的底數	2.718281828459
`i`	虛數單位		表達純虛數	i
`j`	四元數單位j		表達純四元數虛數j
`k`	四元數單位k		表達純四元數虛數k
`nan`	非數		用於表示數學上未定義的數值，或計算發生錯誤的數值。	nan
`nil`	空值	`null`	空值。在math模式下顯示為空白，用於表達或傳遞無參數的函數之參數。請注意，由於此值為空值，因此請勿將此值參與運算，以免發生錯誤。
`°`	角度單位		用於表示角度單位的符號。
`π`	圓周率	`pi`	表示圓周率。	3.1415926535898
`ω`	艾森斯坦整数單位		表達艾森斯坦整数單位。

函數

語法	名稱	參數數量	說明	範例	效果	math輸出
z基礎算术
a `div`	a 分數	2	a 用於在math輸出時，以分數的形式顯示	a `div(7,3)`	a 2.3333333333333	a
a `dot`	a 內積	2	a 計算兩數的內積。	a `dot(7,3)`	a 21	a
a `pow`	a 指數	2	a 計算兩數之冪運算	a `pow(7,3)`	a 343	a
z数论
a `gcd`	a 最大公因數	不定	a 計算多個數的最大公因數。	a `gcd(7,21)`	a 7	a
a `lcm`	a 最小公倍數	不定	a 計算多個數的最小公倍數。	a `lcm(7,3,21)`	a 21	a
a `digits`	a 位數	1	a 取得整數的位數個數	a `digits(7321)`	a 4	a
a `divisor`	a 因數	2	a 取得某數的第n個正因數	a `divisor(6,1),divisor(6,2),divisor(6,3),divisor(6,4)`	a ,	a
a `primedivisor`	a 質因數	2	a 取得某數的第n個質因數	a `primedivisor(210,1),primedivisor(210,2),primedivisor(210,3),primedivisor(210,4)`	a ,	a
a `divisorsigma`	a 除數函數	2	a 計算特定整數的除數函數	a `divisorsigma(1,6)`	a 12	a
a `eulerphi`	a 歐拉函數	1	a 取得小於等於n的正整數中與n互質的數的數目	a `eulerphi(8)`	a	a
a `findnext`	a 向後尋找	2	a 尋找下一個符合條件的整數	a `findnext(:x↦x % 6 = 0;,6)`	a	a
a `findlast`	a 向前尋找	2	a 尋找前一個符合條件的整數	a `findlast(:x↦x % 6 = 0;,10)`	a	a
z初等函數
a `abs`	a 絕對值	1	a 計算一數與原點的歐幾里得距離	a `abs(-3)`	a 3	a
a `log`	a 自然對數	1	a	a `log(e)`	a 1	a
a `log`	a 指定底數的對數	2	a	a `log(2,16)`	a 4	a
a `sgn`	a 符號函數	1	a	a `sgn(-7)`	a -1	a
a `sqrt`	a 平方根	1	a 計算一數的主平方根值	a `sqrt(16)`	a 4	a
a `inverse`	a 倒數	1	a	a `inverse(7)`	a 0.14285714285714	a
a `exp`	a 自然指數	1	a	a `exp(π⋅i)`	a	a
z数值修约
a `floor`	a 地板函數	1	a 向下取整	a `floor(7.3)`	a 7	a
a `ceil`	a 天花板函數	1	a 向上取整	a `ceil(7.3)`	a 8	a
a `round`	a 数值修约	3	a 對一數進行四捨五入。第一參數為欲四捨五入的數字；第二參數為欲四捨五入的位數；第三參數為當數值修約底數非十進制時的底數。	a `round(π,6)`	a 3.141593	a
a `trunc`	a 截尾函數	2	a 對一數取截尾函數。第一參數為欲截尾的數字；第二參數為欲截尾的位數。	a `trunc(π,6)`	a 3.141592	a
z特殊函數
a `binomial`	a 二項式係數	2	a 計算二項式係數。亦可以被理解為從n個相異元素中取出k個元素的方法數。	a `binomial(7,3)`	a 35	a
a `factorial`	a 階乘	1	a 計算一數的階乘	a `factorial(7)`	a 5040	a
a `gamma`	a 伽瑪函數	1	a 計算一數的Γ函数	a `gamma(7)`	a 720	a
a `LambertW`	a 朗伯W函数	2	a 計算一數的朗伯W函数	a `LambertW(1)`	a 0.56714329040978	a
z代数
a `norm`	a 範數	2	a 計算一數或向量的範數	a `norm(3+4i,2)`	a 5	a
a `summation`	a 求和符号	3	a 計算以函數表達之數列的總和。第一參數為數列首項；第二參數為數列末項；第三參數為用以表達數列的函數	a `summation(1,5,:x↦x^2;)`	a	a
a `product`	a 求積符號	3	a 計算以函數表達之數列的連乘積。第一參數為數列首項；第二參數為數列末項；第三參數為用以表達數列的函數	a `product(1,5,:it↦it;)`	a	a
a `<不定>`	a 自行定義函數	不定	a 调用自行定义的函数，這些函數通常是 $\mathbb {C} ^{n}\mapsto \mathbb {C}$ 或 $\mathbb {R} ^{n}\mapsto \mathbb {R}$ 。以`f:x↦x^2;;f(5)`為例，其中`f:x↦x^2;`定義了函數 $f(x)=x^{2}$ ，並调用了函数 $f$ 。函數的語法為以名稱起始並以冒號區隔函數名稱與定義（函數名稱可留空，但冒號不能省去），整個語法要以分號（`;`）結尾。位於映射符號（`↦`）前方為函數的變數或參數，後方為函數主體定義。函數可以有多個變數，但僅能有單個輸出；同時函數語法不建議使用嵌套結構，即不建議將函數定義內包含另一個函數的定義，但可以分開定義再行組合；此外，函數定義內不能包含分號，因為分號會被視為函數結尾。	a `f:x↦x^2;,f(5)`	a	a
a `ele`	a 代數單位元	1	a 取得特定代數空間(如四元數)的第n個單位元，如ele(2)即e₂=j	a `ele(2)`	a	a
z微積分
a `limit`	a 極限	3	a 計算一函數在x=x₀的極限。需注意此運算為估計，運算精度約僅有7位有效數字。第一參數為x₀；第二參數為逼近方向，1表示右極限、-1表示左極限、0表示一般的極限，此時若極限不存在則返回nan；第三參數為欲求極限的函數。	a `limit(0,1,:x↦div(x,x);)`	a	a
a `diff`	a 導數	2	a 計算一函數在x=x₀的導數。需注意此運算為估計，運算精度約僅有7位有效數字。第一參數為欲求導數x=x₀的函數；第二參數為x₀。	a `diff(cos,div(2⋅pi,3))`	a	a
a `integral`	a 定積分	4	a 計算一函數在從a到b的定積分 $\int _{a}^{b}f(x)\,dx$ 。需注意此運算為估計，運算精度約僅有7位有效數字，且積分範圍（a和b的距離）越大，精確度會越低。第一參數為a、第一參數為b、第三參數為欲求定積分的函數、第四參數為取樣數，若未填寫則使用預設值2000。	a `integral(0,π,:x↦sin(x);)`	a	a
z複變
a `re`	a 實數部分	1	a 取得一數的實數部分。	a `re(7+3i)`	a 7	a
a `im`	a 虛數部分	1	a 取得一數的虛數部分	a `im(7+3i)`	a 3	a
a `nonRealPart`	a 非實數部分	1	a 取得一數的非實數部分	a `nonRealPart(7+3i+2j+k)`	a	a
a `scalarPartQuaternion`	a 純量部分	1	a 取得四元數的純量部分	a `scalarPartQuaternion(7+3i+2j+k)`	a	a
a `vectorPartQuaternion`	a 四元數向量部分	1	a 取得四元數的向量部分	a `vectorPartQuaternion(7+3i+2j+k)`	a	a
a `arg`	a 輻角	1	a 計算一複數的輻角	a `arg(3+7i)`	a 1.1659045405098	a
a `cis`	a 純虛指數函數	1	a 計算一數的純虛指數函數值	a `cis(π)`	a -1	a
a `conjugate`	a 共軛複數	1	a	a `conjugate(7+3i)`	a 7-3i	a
z統計
a `average`	a 平均數	不定	a 計算數組的算術平均數。	a `average(7,3,2,1)`	a 3.25	a
a `geoaverage`	a 幾何平均數	不定	a 計算數組的幾何平均數	a `geoaverage(7,3,2,1)`	a 2.5457298950218	a
a `maximum`	a 最大值	不定	a 計算數組的最大值	a `maximum(7,3,2,1)`	a 7	a
a `minimum`	a 最小值	不定	a 計算數組的最小值	a `minimum(7,3,2,1)`	a 1	a
a `selectlist`	a 數組元素	不定	a 輸出數組中指定位置的元素。第一參數為要輸出的元素序號，第二參數之後為數組	a `selectlist(2,7,3,2,1)`	a 3	a
a `σ`	a 標準差	不定	a 計算數組的標準差	a `σ(7,3,2,1)`	a 2.2776083947861	a
z技術性
a `hide`	a 隱藏運算式	不定	a 在math模式下隱藏指定運算式。本函數的結果為最後一個參數。可作為連續運算式的表達，所有已輸入的運算式皆會計算，但結果會隱藏。亦可用於自訂函數中的多運算式表達。	a `hide(y←5,x←7,x⋅y),5`	a	a
a `exprs`	a 一系列運算式	不定	a 在math模式時顯示所有運算式，運算結果為最後一則運算式。可作為連續運算式的表達，所有已輸入的運算式皆會計算。	a `exprs(y←5,x←7,x⋅y),5`	a	a
a `lastexpr`	a 最後一則運算式	不定	a 在math模式時顯示最後一則運算式，運算結果也為最後一則運算式。可作為連續運算式的表達，所有已輸入的運算式皆會計算。	a `lastexpr(y←5,x←7,x⋅y),5`	a	a
a `equalexpr`	a 連續等式	不定	a 生成連續等式。	a `equalexpr(2+2,2*2)`	a 4	a
a `call`	a 呼叫函數	不定	a 呼叫一個函數。用於處理匿名函數或返回值是函數的情況。	a `call((:x,y↦sin(x)+cos(y);),π,0)`	a	a
a `<functionName>AtModule<ModulePageName>`	a 调用其他模块	不定	a 调用其他模块的函数。須注意函數名稱必須是純英文、模組名稱也必須是純英文，不能有空格或其他符號。例如若需要呼叫Module:Element中的`getAtomicWeight`函數，則須表示為`getAtomicWeightAtModuleElement`。	a `getAtomicWeightAtModuleElement(10)`	a	a
a `range`	a 指定範圍	3	a 指定一範圍，當一數落在該範圍外則視為非數（NaN）。第一參數為要判定的數，第二和第三參數分別為範圍的最小和最大值。	a `range(7,1,5),range(4,1,5)`	a ,	a
a `if`	a 條件運算式	3	a 指定特定條件下時的運算式。第一參數為條件、第二參數為條件為真時的運算式、第三參數為條件為假時的運算式。	a `if(3>2,1,0)`	a 0	a
a `iff`	a 函數型條件運算式	3	a 同if，不過參數可以是函數，條件成立時才會呼叫。	a `iff(3>2,:nil↦1;,:nil↦2;)`	a	a
a `ifelse`	a 條件運算式 if...else	不定	a 類似if，用法為ifelse(條件1, 條件1為真的結果, 條件2, 條件2為真的結果, ... , 條件n, 條件n為真的結果, 條件皆為假的結果)	a `ifelse(3>2,10,3<2,20,30)`	a 0	a
a `ifelsef`	a 函數型條件運算式 if...else	不定	a 同ifelse，不過參數可以是函數，條件成立時才會呼叫。	a `ifelsef(3>2,:nil↦10;,3<2,:nil↦20;,:nil↦30;)`	a	a
a `random`	a 隨機數	2	a 取一個隨機數。若無指定參數，或參數中包含非數（NaN），則取0-1之間的隨機實數；若指定了參數1，則取1到參數1之間的隨機數；若指定了參數1與參數2，則取參數1到參數2之間的隨機數	a `random(1,10)`	a 3	a
a `randomseed`	a 設定隨機種子碼	1	a 將隨機數的種子碼設定為輸入的參數，並返回實際設定的種子碼。若輸入的參數非實數則用當前時間隨機產生種子碼。	a `randomseed(10)`	a 10	a
z三角函数
a `sin`	a 正弦	1	a 計算一數的正弦值	a `sin(π)`	a 0	a
a `cos`	a 餘弦	1	a 計算一數的餘弦值	a `cos(π)`	a -1	a
a `tan`	a 正切	1	a 計算一數的正切值	a `tan(π)`	a 0	a
a `cot`	a 餘切	1	a 計算一數的餘切值	a `cot(div(π,2))`	a -8.1656196765977e+15	a
a `sec`	a 正割	1	a 計算一數的正割值	a `sec(π)`	a -1	a
a `csc`	a 餘割	1	a 計算一數的餘割值	a `csc(div(π,2))`	a 8.1656196765977e+15	a
a `asin`	a 反正弦	1	a 計算一數的反正弦值	a `asin(1)`	a 1.5707963267949	a
a `acos`	a 反餘弦	1	a 計算一數的反餘弦值	a `acos(1)`	a 0	a
a `atan`	a 反正切	1	a 計算一數的反正切值	a `atan(1)`	a 0.78539816339745	a
a `acot`	a 反餘切	1	a 計算一數的反餘切值	a `acot(1)`	a 0.78539816339745	a
a `asec`	a 反正割	1	a 計算一數的反正割值	a `asec(1)`	a 0	a
a `acsc`	a 反餘割	1	a 計算一數的反餘割值	a `acsc(1)`	a 1.5707963267949	a
a `sinh`	a 雙曲正弦	1	a 計算一數的雙曲正弦值	a `sinh(π)`	a 11.548739357258	a
a `cosh`	a 雙曲餘弦	1	a 計算一數的雙曲餘弦值	a `cosh(π)`	a 11.591953275522	a
a `tanh`	a 雙曲正切	1	a 計算一數的雙曲正切值	a `tanh(π)`	a 0.99627207622075	a
a `coth`	a 雙曲餘切	1	a 計算一數的雙曲餘切值	a `coth(π)`	a 1.0037418731973	a
a `sech`	a 雙曲正割	1	a 計算一數的雙曲正割值	a `sech(π)`	a 0.086266738334054	a
a `csch`	a 雙曲餘割	1	a 計算一數的雙曲餘割值	a `csch(π)`	a 0.086589537530047	a
a `asinh`	a 雙曲反正弦	1	a 計算一數的雙曲反正弦值	a `asinh(1)`	a 0.88137358701954	a
a `acosh`	a 雙曲反餘弦	1	a 計算一數的雙曲反餘弦值	a `acosh(1)`	a 0	a
a `atanh`	a 雙曲反正切	1	a 計算一數的雙曲反正切值	a `atanh(0.5)`	a 0.54930614433405	a
a `acoth`	a 雙曲反餘切	1	a 計算一數的雙曲反餘切值	a `acoth(1.5)`	a 0.80471895621705	a
a `asech`	a 雙曲反正割	1	a 計算一數的雙曲反正割值	a `asech(1)`	a 0	a
a `acsch`	a 雙曲反餘割	1	a 計算一數的雙曲反餘割值	a `acsch(1)`	a 0.88137358701954	a
a `cis`	a 純虛指數函數	1	a 計算一數的純虛指數函數值	a `cis(π)`	a -1	a
a `gd`	a 古德曼函數	1	a 計算一數的古德曼函數值	a `gd(e)`	a 1.4390113159637	a
a `arcgd`	a 反古德曼函數	1	a 計算一數的反古德曼函數值	a `arcgd(1)`	a 1.2261911708835	a
a `cogd`	a 餘古德曼函數	1	a 計算一數的餘古德曼函數值	a `cogd(π)`	a 0.08648169656714	a

上述文档嵌入自Module:Complex Number/Calculate/doc。
编者可以在本模块的沙盒和测试样例页面进行实验。
本模块的子页面。

local p = {}
function p.calculate(frame)
    local args
    local can_math = false
    if frame == mw.getCurrentFrame() then
        -- We're being called via #invoke. The args are passed through to the module
        -- from the template page, so use the args that were passed into the template.
        args = frame.args
        local yesno = require('Module:Yesno')
        can_math = yesno(args['use math'] or args['use_math'])
    else
        -- We're being called from another module or from the debug console, so assume
        -- the args are passed in directly.
        args = frame
    end
	local body = p.calc( args[1] or args['1'] or '', ( {
		cmath = require("Module:Complex Number").cmath.init(),
	} ) [ args['class'] ] , (( {
		cmath = require("Module:Complex Number").cmath.init(),
	} ) [ args['class'] ] ).toComplexNumber )
	if can_math then body = frame:callParserFunction{name = "#tag:math", args = {body}} end
	return body
end

function p.toPostfix(frame)
    local args
    if frame == mw.getCurrentFrame() then
        -- We're being called via #invoke. The args are passed through to the module
        -- from the template page, so use the args that were passed into the template.
        args = frame.args
    else
        -- We're being called from another module or from the debug console, so assume
        -- the args are passed in directly.
        args = frame
    end
	local format =  args['format'] or "{{{1}}} ";
	format = mw.ustring.gsub(format, "%{%{%{.-%}%}%}", "%%s" );
	local it = mw.ustring.find(format, "%%s", 1)
	format = mw.ustring.gsub(format, "\\n", "\n")
	local result, body = p.infixToPostfix( args[1] or args['1'] or '' ), ''
	for i, result_str in pairs( result ) do
		body = body .. mw.ustring.gsub(format, "%%s", tostring(result_str.name)) 
	end
	return body
end

function numberToAZ(num)
	local body = ''
	local s = tostring(math.floor(tonumber(num)))
	for i = 1, #s do
		body = body .. mw.ustring.char(tonumber(s:sub(i, i)) + 65)
	end
	return body
end

function stringToTable(s) --字串轉陣列
	local t, i = {}, 1
	while i <= #s do
		if s:sub(i, i) ~= ' ' then
			local j, k = mw.ustring.find(s,"[%d%a]+",i)
			if (j or (i+1)) > i then
				t[#t + 1] = s:sub(i, i)
			else
				t[#t + 1] = s:sub(j, k)
				i = k
			end
		end
		i = i + 1
	end
	return t
end

--mw.log(p.calc("45*5+(1+5-9+((12-5)+5i+(9)/4)*sqrt(-6))*-8",require("Module:Complex Number").cmath.init(),require("Module:Complex Number").cmath.init().toComplexNumber,true))
-- 346.97959 - 181.262241 i
--mw.log(p.calc("45*5+(1+5-9+((12-5)+5+(9)/4)*sin(-6))*-8",nil,nil,true))
-- 217.146633205
--mw.log(p.calc("(i*j*k)",p.qmath.init(),p.qmath.init().toQuaternionNumber,true))
-- (-1)
function p.calc(input_str, math_lib, number_Constructer, debug_flag)
	local mathlib, numberConstructer = math_lib or math, number_Constructer or tonumber
	local postfix = p.infixToPostfix(input_str, debug_flag)
	local call_stack = {}
	local calc_stack = {}
	local dbg_func = mw.log
	if debug_flag ~= true then dbg_func = function()end end
	for i = 1,#postfix do
		local it = postfix[i]
		if it.propetry == "operator" then
			local opdata = p.symbol_table[it.name]
			xpcall(function() 
				if it.name == ',' then
					if calc_stack[#calc_stack-1] ~= ',' then call_stack[#call_stack + 1] = calc_stack[#calc_stack-1] end 
					if calc_stack[#calc_stack] ~= ',' then call_stack[#call_stack + 1] = calc_stack[#calc_stack] end 
					calc_stack[#calc_stack] = nil; calc_stack[#calc_stack] = ','
				elseif opdata.count == 1 then
					calc_stack[#calc_stack] = opdata.calc(calc_stack[#calc_stack],mathlib,numberConstructer)
				else
					calc_stack[#calc_stack - 1] = opdata.calc(calc_stack[#calc_stack - 1]or 0 ,calc_stack[#calc_stack]or 0,mathlib,numberConstructer)
					calc_stack[#calc_stack] = nil
				end
			end, function(message)
				error("計算失敗：套用運算子 \"" .. mw.text.trim(it.name) .. "\" 發生錯誤 \"" .. message .. "\" .")
			end)
			xpcall(function() (calc_stack[#calc_stack]):clean() end,function(_)end)
			dbg_func(it.name, '\t', print_sk(calc_stack,', ') )
		elseif it.propetry == "func" then
			local calfunc, functype = mathlib[it.name], type(tonumber)
			if type(calfunc) ~= functype and type(_G[it.name]) == functype then calfunc = _G[it.name] end
			if type(calfunc) == functype then
				xpcall(function() 
					if #call_stack > 0 then
						calc_stack[#calc_stack] = calfunc( unpack( call_stack ) )
					else
						calc_stack[#calc_stack] = calfunc( calc_stack[#calc_stack] )
					end
				end, function(message)
					error("計算失敗：執行函數 \"" .. it.name .. "\" 發生錯誤 \"" .. message .. "\" .")
				end)
			else
				error("計算失敗：無法執行函數 \"" .. it.name .. "\" ")
			end
			xpcall(function() (calc_stack[#calc_stack]):clean() end,function(_)end)
			dbg_func(it.name, '\t', print_sk(calc_stack,', ') )
		else
			local get_data = numberConstructer(it.name)
			if get_data == nil then get_data = numberConstructer(_G[it.name]) or numberConstructer(mathlib[it.name]) or numberConstructer(it.name) end
			if get_data == nil then error("計算失敗：未知的變數 \"" .. it.name .. "\" ") end
			calc_stack[#calc_stack + 1] = get_data
			xpcall(function() (calc_stack[#calc_stack]):clean() end,function(_)end)
			dbg_func(it.name, '\t', print_sk(calc_stack,', ') )
		end
	end
	if #calc_stack == 1 then return calc_stack[#calc_stack] end
	return numberConstructer(0)
end

p.symbol_table = {
		['+'] = { propetry="op", multp = true, count = 2, priority=2, calc=function(a,b,c,d)return d(a)+d(b) end},
		["+ "] = { propetry="op", count = 1, priority=5, calc=function(a,c,d)return d(a) end},
		['-'] = { propetry="op", multp = true, count = 2, priority=2, calc=function(a,b,c,d)return d(a)-d(b) end},
		["- "] = { propetry="op", count = 1, priority=5, calc=function(a,c,d)return -d(a) end},
		['*'] = { propetry="op", multp = true, count = 2, priority=3, calc=function(a,b,c,d)return d(a)*d(b) end},
		["* "] = { propetry="op", count = 1, priority=5 , calc=function(a,c,d) if type(c.conjugate)==type(function()end) then return c.conjugate(d(a))else return d(a)end end},
		['/'] = { propetry="op", count = 2, priority=3, calc=function(a,b,c,d)return d(a)/d(b) end},
		['%'] = { propetry="op", count = 2, priority=3, calc=function(a,b,c,d)return d(a)%d(b) end},
		['^'] = { propetry="op", count = 2, priority=4, calc=function(a,b,c,d)return c.pow(d(a),d(b)) end},
		[','] = { propetry="op", count = 2, priority=1 },
}

	function print_sk(sk,sp)
		local body = ''
		for i = 1,#sk do
			if body ~= '' then body = body .. (sp or ' ') end
			if type(sk[i]) == type({}) and sk[i].name then if sk[i].name == "$END" then body = body .. '$' else body = body .. sk[i].name end
			else body = body .. tostring(sk[i]) end
		end
		return body
	end

function p.infixToPostfix(input_str, debug_flag)
	local str, index, num_list = input_str, 0, {}; 
	local dbg_func = mw.log
	if debug_flag ~= true then dbg_func = function()end end
	str = mw.ustring.gsub(str,"([A-Za-hj-z])i","%1I")
	str = mw.ustring.gsub(str,"([A-Za-ik-z])j","%1J")
	str = mw.ustring.gsub(str,"([A-Za-jl-z])k","%1K")
	str = mw.ustring.gsub(str,"i([A-Za-hj-z])","I%1")
	str = mw.ustring.gsub(str,"j([A-Za-ik-z])","J%1")
	str = mw.ustring.gsub(str,"k([A-Za-jl-z])","K%1")
	local result = mw.ustring.gsub(str,"%d*%.?%d*%s*[ijk]?",
		function(b) 
			if b ~= nil and mw.text.trim(b) ~= '' then 
				index = index + 1 
				num_list[#num_list + 1] = b 
				return tostring(index) 
			end 
			return ''
		end 
	); 
	result = mw.ustring.gsub(result,"I","i")
	result = mw.ustring.gsub(result,"J","j")
	result = mw.ustring.gsub(result,"K","k")
	--------------------------------------------------------
	local str2, index, azid, func_list = result, 0, '', {}; 
	local result = mw.ustring.gsub(str2,"%a[%a%d]*%s*%(?",
		function(b) 
			if b ~= nil and mw.text.trim(b) ~= '' then 
				if mw.ustring.find(b,"%(") then
					local func_name = mw.ustring.match(b,"%a[%a%d]*")
					if func_name ~= nil and mw.text.trim(func_name) ~= '' then  
						index, azid = index + 1, numberToAZ(index)
						func_list[azid] = func_name 
						return ' ' .. azid .. ' '
					end
				else
					num_list[#num_list + 1] = b 
					return tostring(#num_list) 
				end
			end 
			return ''
		end 
	); 
	for i=1,#num_list do num_list[i] = mw.ustring.gsub(num_list[i],"%s+",'') end
	
	local mid_expr = stringToTable(result)
	mid_expr[#mid_expr + 1] = "$END"
	local stack, postfix = {{name="$END",elements=0}}, {}
	for i = 1,#mid_expr do
		local it = mid_expr[i]
		if it == "$END" then
			while #stack > 0 and stack[#stack].name ~= "$END"  do
				if stack[#stack].elements < p.symbol_table[stack[#stack].name].count then
					dbg_func("==operator ",stack[#stack].name, " need ",p.symbol_table[stack[#stack].name].count, " elements, but got ",stack[#stack].elements)
					return {}
				end
				postfix[#postfix + 1] = {name=stack[#stack].name, propetry=stack[#stack].propetry}
				stack[#stack] = nil --pop
				stack[#stack].elements = (stack[#stack].elements or 0) + 1
			end
			dbg_func("結束",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack))
		elseif mw.ustring.match(it,"[%a%(]") then
			stack[#stack + 1] = {name=it,elements=0,propetry='func'}
			dbg_func(it, "括號開始",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack))
		elseif p.symbol_table[it] ~= nil and p.symbol_table[it].propetry == "op" then
			local op_it = p.symbol_table[it]
			local op_ls = p.symbol_table[mid_expr[i-1]]
			local flag = mw.ustring.match(mid_expr[i-1] or '',"[%a%(]") if (mid_expr[i-1] or '娜娜奇') == '娜娜奇' then flag = false end
			if ( op_ls or (i == 1) or flag ) and op_it.multp == true then
				stack[#stack + 1] = {name=it .. ' ',elements=0,propetry='operator'}
			else
				while p.symbol_table[stack[#stack].name] and p.symbol_table[stack[#stack].name].priority and
					p.symbol_table[stack[#stack].name].priority >= p.symbol_table[it].priority do
						if stack[#stack].elements < p.symbol_table[stack[#stack].name].count then
							dbg_func("==operator ",stack[#stack].name, " need ",p.symbol_table[stack[#stack].name].count, " elements, but got ",stack[#stack].elements)
							return {}
						end
					postfix[#postfix + 1] = {name=stack[#stack].name, propetry=stack[#stack].propetry}
					stack[#stack] = nil --pop
					stack[#stack].elements = (stack[#stack].elements or 0) + 1
				end
				stack[#stack + 1] = {name=it,elements=1, propetry='operator'}
			end
			dbg_func(it, "運算子",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack))
		elseif mw.ustring.match(it,"%d+") then
			postfix[#postfix + 1] = {name=num_list[tonumber(it)] or ("N" .. it), propetry="number"}
			stack[#stack].elements = (stack[#stack].elements or 0) + 1
			dbg_func(it, "數字",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack))
		elseif it == ')' then
			local flag = mw.ustring.match(stack[#stack].name,"[%a%(]")
			while flag == nil do --遇 ) 輸出至 ( 
				if stack[#stack].elements < p.symbol_table[stack[#stack].name].count then
					dbg_func("==operator ",stack[#stack].name, " need ",p.symbol_table[stack[#stack].name].count, " elements, but got ",stack[#stack].elements)
					return {}
				end
				postfix[#postfix + 1] = {name=stack[#stack].name, propetry=stack[#stack].propetry}
				stack[#stack] = nil --pop
				stack[#stack].elements = (stack[#stack].elements or 0) + 1
				flag = mw.ustring.match(stack[#stack].name,"[%a%(]")
			end
			if mw.ustring.match(stack[#stack].name,"%a") then
				postfix[#postfix + 1] = {name=func_list[stack[#stack].name] or stack[#stack].name, propetry=stack[#stack].propetry}
			end
			stack[#stack] = nil --pop
			stack[#stack].elements = (stack[#stack].elements or 0) + 1
			dbg_func(it, "結束括號",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack))
		end
	end
	return postfix

end
return p