Editing Module:Complex Number/Calculate

local p = {}
local getArgs = require('Module:Arguments').getArgs
local ext_mathlib = require("Module:Complex Number/Functions")._init
local comp_number = nil
local TrackingCategory = require('Module:TrackingCategory')
local Operators = require('Module:Complex_Number/Calculate/Operators')
local strip_marker_temp, strip_marker_temp_len = {}, 0
local noop_func = function()end
p.use_other_module = false
p.symbol_table=Operators.symbol_table
--======== public tools ========
function p._remove_strip_marker(str)return mw.text.decode(mw.text.unstrip(str)) end
function p._load_strip_marker(str)return mw.ustring.gsub(mw.text.decode(mw.text.unstripNoWiki(str)),"\127'\"`UNIQ.-QINU`\"'\127",function(strip)
	strip_marker_temp_len = strip_marker_temp_len + 1
	local idx_az = numberToAZ(strip_marker_temp_len)
	strip_marker_temp[idx_az] = strip
	return ' UNQ' .. idx_az .. ' '
end)end
function p._function_preprocessing(input_str,math_lib, number_Constructer, debug_flag, jsut_load)
	local input_fo, ftable = Operators.function_preload(input_str,{},math_lib, number_Constructer, debug_flag, p.nocalc, jsut_load)
	if type(ftable)~=type({"table"})then return input_fo, {} end
	local final_scope=Operators.fill_function(ftable,{})
	final_scope=Operators.fill_scope(final_scope, math_lib, number_Constructer, debug_flag, p.calc_by_postfix)
	return input_fo, final_scope
end
function p._re_math_output(unmathstr)
	return tostring(p._preCalculate({tostring(unmathstr):gsub('%*','⋅'),class="mathtag"}))
end
function p._adj_math_output(unmathstr)
	return mw.text.trim(mw.ustring.gsub(" "..unmathstr.." ","ω","\\omega "):gsub("ε","\\varepsilon ")
		:gsub("([^%a])inf([^%a])","%1\\infty %2"):gsub("([^%a])nan([^%a])","%1\\mathrm{NaN}%2")
		:gsub("([%+%-]?)(%d*%.?%d+)e([%+%-]?%d+)","%1%2\\times 10^{%3}"))
end
function p._randomseed()math.randomseed(math.floor(os.time() * os.clock()))end

function p._getNumString(input_string, exp_flag)
	local str, shift_digits = p.scientific2number(mw.ustring.upper(input_string), exp_flag)
	local int_digits, float_digits = {}, {}
	if mw.ustring.find(input_string, "[;:]") then
		str = mw.ustring.gsub(str, "[^;:,%d%.]", "")
		local pre_digits = mw.text.split(str, "[,:]")
		local doing_int = true
		for i=1,#pre_digits do
			if doing_int then
				local find_point = mw.ustring.find(pre_digits[i], "[;%.]")
				if find_point then
					doing_int = false
					int_digits[#int_digits + 1] = tonumber( ({mw.ustring.gsub(mw.ustring.sub(pre_digits[i], 1, find_point-1), "[;%.]", "")})[1] ) or 0
					float_digits[#float_digits + 1] = tonumber( ({mw.ustring.gsub(mw.ustring.sub(pre_digits[i], find_point+1, -1), "[;%.]", "")})[1] ) or 0
				else
					int_digits[#int_digits + 1] = tonumber( ({mw.ustring.gsub(pre_digits[i], "[;%.]", "")})[1] ) or 0
				end
			else
				float_digits[#float_digits + 1] = tonumber( ({mw.ustring.gsub(pre_digits[i], "[;%.]", "")})[1] ) or 0
			end
		end
		if #int_digits == 0 then int_digits[1] = 0 end
		if #float_digits == 0 then float_digits[1] = 0 end
	else
		str = mw.ustring.gsub(str, "[^%.%d%a]", "")
		local point_pos = mw.ustring.find(str, "%.")
		local int_str, float_str = ((point_pos or 2) <= 1) and "0" or mw.ustring.sub(str, 1, (point_pos or 0)-1), point_pos and mw.ustring.sub(str, point_pos+1, -1) or ''
		float_str = mw.ustring.gsub(float_str, "%.", "")
		local char_0 = mw.ustring.codepoint('0')
		local char_A = mw.ustring.codepoint('A')
		local char_Z = mw.ustring.codepoint('Z')
		local int_strlen, float_strlen = mw.ustring.len(int_str), mw.ustring.len(float_str)
		for i=1,int_strlen do
			local code_point = mw.ustring.codepoint(mw.ustring.sub(int_str,i,i))
			if code_point < char_A and code_point >= char_0 then code_point = code_point - char_0
			elseif code_point <= char_Z then code_point = code_point - char_A + 10 end
			int_digits[i] = code_point
		end
		for i=1,float_strlen do
			local code_point = mw.ustring.codepoint(mw.ustring.sub(float_str,i,i))
			if code_point < char_A and code_point >= char_0 then code_point = code_point - char_0
			elseif code_point <= char_Z then code_point = code_point - char_A + 10 end
			float_digits[i] = code_point
		end
	end
	return int_digits, float_digits
end

--======== local tools ========
local function numberToAZ(num)
	local body = ''
	local s = tostring(math.floor(tonumber(num)))
	for i = 1, mw.ustring.len(s) do
		local char_id = tonumber(mw.ustring.sub(s, i, i)) + 65
		char_id = char_id + ((char_id >= 73) and 3 or 0)
		body = body .. mw.ustring.char(char_id)
	end
	return body
end
local function _subst_strip(str)
	local UNIQ mw.ustring.gsub(str, "UNQ(%a+)$", function(num) UNIQ = UNIQ or num end)
	return strip_marker_temp[UNIQ or -1] or str
end
local function _subst_error_strip(str)
	local UNIQ mw.ustring.gsub(str, "UNQ(%a+)$", function(num) UNIQ = UNIQ or num end)
	return mw.ustring.gsub(strip_marker_temp[UNIQ or -1] or str, "\127'\"`UNIQ%-%-(%a+).-QINU`\"'\127", "<%1></%1>")
end
local function stringToTable(s) --字串轉陣列
	local t, i = {}, 1
	while i <= mw.ustring.len(s) do
		if mw.ustring.sub(s, i, i) ~= ' ' then
			local j, k = mw.ustring.find(s,"[%d%a]+",i)
			if (j or (i+1)) > i then
				t[#t + 1] = mw.ustring.sub(s, i, i)
			else
				t[#t + 1] = mw.ustring.sub(s, j, k)
				i = k
			end
		end
		i = i + 1
	end
	return t
end
local function print_sk(sk,sp)
	local body, sp_checker = '', mw.text.trim(sp or '')
	for i = 1,#sk do
		local checker = ((type(sk[i]) == type({})) and sk[i].name or nil) or sk[i]
		if type(checker) == type({}) then 
			local cats = ""
			for cati=1,#checker do if cats ~= "" then cats = cats .. ',' end cats = cats .. tostring(checker[cati])end checker = cats
		end
		if mw.text.trim( (type(checker)==type(noop_func))and "function" or checker  ) ~= sp_checker then
			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 
				if tostring(sk[i]) == 'table' and sk[i].assign=="assign" then body = body .. (tostring(sk[i][1])=="$END" and "${字串結尾}" or _subst_error_strip(tostring(sk[i][1])))
				else body = body .. _subst_error_strip(tostring(sk[i])) end
			end
		end
	end
	return body
end
--======== template tools ========
function p.checkModuleClass(cls)
	local class = ((type(cls)==type({}))and( ((cls.args or {})[1]) or cls[1] or '')or( (type(cls)==type("string")) and cls or ''))or''
	if mw.ustring.sub(class,1,7):upper()=="MODULE:" then
		local data = mw.ustring.sub(class, 8, -1)
		local func = mw.ustring.find(data,"%.")
		local modu = mw.ustring.sub(data, 1, func -1)
		func = mw.ustring.sub(data, func + 1, -1)
		return mw.text.trim(modu),  mw.text.trim(func)
	end
	return ''
end
function p.scientific2number(input_str, exp_flag)
	local inputstr = input_str
	if type(input_str) == type({"table"}) then
		inputstr = (input_str.args or {})[1] or input_str[1] or ''
	elseif type(input_str) ~= type("string") then
		inputstr = tostring(input_str)
	end
	local input_numstr = mw.text.trim(inputstr)
	local numstr, flag = input_numstr
	local exp_num = 0
	local sign_str = mw.ustring.sub(numstr,1,1)
	if not (sign_str=='+' or sign_str=='-' or sign_str=='−') then 
		sign_str='' 
	else
		numstr = mw.ustring.sub(numstr,2,-1)
	end
	numstr, flag = mw.ustring.gsub(numstr, "^%s*([%d%.]+)%s*[Ee]%s*([+-−]"..(exp_flag and '' or '-').."%d+)%s*$", function(number_name, dig_str)
		local digits = mw.ustring.gsub(dig_str, "%+", "")
		digits = mw.ustring.gsub(digits, "[-−]+", "-")
		exp_num = tonumber(digits) or 0
		return number_name
	end)
	numstr = numstr ..'.'
	if flag <= 0 then return input_numstr end
	numstr = mw.ustring.gsub(numstr, "[^%d%.]", "")
	local pti, ptat = 0, (({mw.ustring.find(numstr, "%.")})[1]or 2)-1
	numstr = mw.ustring.gsub(numstr, "%.", "")
	local numlen = mw.ustring.len(numstr)
	if ptat + exp_num > 0 then
		if numlen < ptat + exp_num then
			numstr = numstr .. string.rep( '0', ptat + exp_num - numlen )
		elseif numlen > ptat + exp_num then
			numstr = mw.ustring.sub(numstr, 1, ptat + exp_num)..'.'..mw.ustring.sub(numstr, ptat + exp_num+1, -1)
		end
	elseif ptat + exp_num <= 0 then
		numstr = '0.' .. ((ptat + exp_num==0) and '' or string.rep( '0', - ptat - exp_num )) .. numstr
	end
	return sign_str .. numstr
end
--======== main ========
function p._preCalculate(frame, error_func)
    local args
    local can_math = false
    local should_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 = getArgs(frame) --frame.args
        local yesno = require('Module:Yesno')
        can_math = yesno(args['use math'] or args['use_math'])
        should_math = yesno(args['should math'] or args['should_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 yesno = require('Module:Yesno')
    if yesno(args.useOtherModule or 'no') == true then p.use_other_module = true end
	if comp_number == nil then comp_number = require("Module:Complex Number") end
    local cmath, qmath, bmath = comp_number.cmath.init(), comp_number.qmath.init(), comp_number.bmath.init()
    local mathtag = p.tagmath.init()

    local math_class = args['class']or''
    if mw.text.trim(math_class) == '' then math_class = "cmath" end
    local mymath = cmath
    local mytomath = cmath.toComplexNumber
    if mw.ustring.sub(math_class,1,7):upper()=="MODULE:" then
		local module_name, math_lib_name = p.checkModuleClass(math_class)
		xpcall(function()
			local load_module = require("Module:"..module_name)
			if load_module ~= nil then
				local load_math_lib = load_module[math_lib_name]
				if load_module ~= nil then
					local func_type = type(noop_func)
					local my_math_lib = (type(load_math_lib.init) == func_type) and load_math_lib.init() or load_math_lib
					if type(my_math_lib.constructor) == func_type then
						math_class = "mymath"
						mymath = my_math_lib
						mytomath = my_math_lib.constructor
					end
				end
			end
		end,noop_func)
	end
    local input_math_lib = ( {
		cmath = cmath,
		qmath = qmath,
		bmath = bmath,
		mathtag = mathtag,
		mymath = mymath
	} ) [ math_class ]
	local input_to_number = (( {
		cmath = cmath.toComplexNumber,
		qmath = qmath.toQuaternionNumber,
		bmath = bmath.toBoolean,
		mathtag = mathtag.toTagMath,
		mymath = mytomath
	} ) [ math_class ] )
	return p.calc(p._load_strip_marker(args[1] or args['1'] or ''), input_math_lib , input_to_number, nil, nil, error_func ), 
		can_math, should_math, input_math_lib, input_to_number, args
end
function p.templateCalculate(frame)
    p._randomseed()
	local body, can_math, should_math, input_math_lib, input_to_number, args = p._preCalculate(frame)
	if type(body) == type("string") then
		if body:find("function") then
			body = body:gsub("function([A-Z]+)",function(func_id)
				local result = func_id:gsub("[A-Z]",function(char_it)
					local char_id = char_it:byte(1,1)
					local num_id = char_id - 65
					return tostring(num_id - ((num_id>=10) and 3 or 0))
				end)
				return "function"..result
			end)
		end
	end
	if should_math or can_math then 
		local yesno = require('Module:Yesno')
		if args.class ~= "mathtag" and yesno(args['show math'] or args['shw_math']) then
			body = p._re_math_output(body)
		end
		body = p._adj_math_output(tostring(body)) 
	end
	if can_math then body = frame:callParserFunction{name = "#tag:math", args = {tostring(body)}} end
	return body
end
function p.calculate(frame)
    p._randomseed()
	local body, can_math, should_math = p._preCalculate(frame)
	if should_math or can_math then body = p._adj_math_output(tostring(body)) end
	if can_math then body = frame:callParserFunction{name = "#tag:math", args = {tostring(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 = getArgs(frame, {
        	trim = false,
			removeBlanks = false
        }) --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 = mw.text.decode(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 expr_geter = p._function_preprocessing(p._load_strip_marker(args[1] or args['1'] or ''),{}, nil, nil, true)
	local result, body = p.infixToPostfix( expr_geter ), ''
	for i, result_str in pairs( result ) do
		if type(result_str)==type({}) and mw.text.trim(result_str.name) ~= '|' and result_str.propetry ~= "func start" then
			body = body .. mw.ustring.gsub(format, "%%s", _subst_strip(mw.text.trim(tostring(result_str.name))))
		elseif type(result_str)==type("string") then
			body = body .. mw.ustring.gsub(format, "%%s", _subst_strip(mw.text.trim(tostring(result_str))))
		end
	end
	return body
end

function p.toPrefix(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 = getArgs(frame, {
        	trim = false,
			removeBlanks = false
        }) --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 = mw.text.decode(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 expr_geter = p._function_preprocessing(p._load_strip_marker(args[1] or args['1'] or ''),{}, nil, nil, true)
	local postfix, body = p.infixToPostfix( expr_geter ), ''
	local pre_stack = {}
	local cmt_str = ""
	local cmt_count = 0
	local function _item_tostring(item)return _subst_strip((type(item)==type({"table"}))and(item.name or tostring(item))or tostring(item))end
	local function tail_process()
		if cmt_str ~= "" then
			local oper_out_format = (cmt_count==2) and "%s , %s" or ((cmt_count==1) and "%s %s" or "%s (, %s)")
			pre_stack[#pre_stack<=0 and 1 or #pre_stack] = mw.ustring.format(oper_out_format,
				_item_tostring(pre_stack[#pre_stack]and(pre_stack[#pre_stack]..' ')or''),
				_item_tostring(cmt_str)
			)
			cmt_str = ""
		else
			local new_top = ''
			for i=1,#pre_stack do
				if new_top ~= '' then new_top = new_top .. ' ' end
				new_top = new_top .. _item_tostring(pre_stack[i])
			end
			for i=#pre_stack,1,-1 do pre_stack[i] = nil end
			pre_stack[1] = new_top
		end
	end
	for i = 1,#postfix do
		local it = postfix[i]
		local opdata = (it.propetry == "operator") and p.symbol_table[it.name] or {count=0}
		if it.name == "," then
		--case 逗號
			if cmt_str == "" then
				if #pre_stack >= 2 then
					cmt_str = mw.ustring.format("%s %s",
						_item_tostring(pre_stack[#pre_stack-1]), 
						_item_tostring(pre_stack[#pre_stack]))
					cmt_count = 2
					pre_stack[#pre_stack] = nil
				else
					cmt_str = _item_tostring(pre_stack[#pre_stack]or ' ')
					cmt_count = mw.test.trim(cmt_str)=='' and 0 or 1
				end 
			else
				local new_cmt = (pre_stack[#pre_stack]and(' '.._item_tostring(pre_stack[#pre_stack])))or ''
				cmt_str = cmt_str .. new_cmt
				cmt_count = cmt_count + (mw.text.trim(new_cmt)=='' and 0 or 1)
			end
			pre_stack[#pre_stack] = nil
		elseif it.propetry == "func start" then
			pre_stack[#pre_stack+1] = "$function_start\127"
		elseif it.propetry == "func" then
			local par_count = 0
			local find_func_head = #pre_stack while not mw.ustring.find(_item_tostring(pre_stack[find_func_head]),"%$function_start\127") do
				if find_func_head < 1 then par_count = 0 break end
				par_count = par_count + 1
				find_func_head = find_func_head - 1
			end
			local par_data = _item_tostring(pre_stack[find_func_head]or'$function_start\127')
			find_func_head = find_func_head <= 0 and #pre_stack or find_func_head
			local mark_start, mark_end = mw.ustring.find(par_data,"%$function_start\127")
			par_data = mw.text.split(mark_start and par_data or "$function_start\127","%$function_start\127")
			local tail_data = ''
			if cmt_str ~= "" then
				tail_data = mw.ustring.format("%s %s",_item_tostring(par_data[2]),_item_tostring(cmt_str))
				par_count = par_count + cmt_count
			end
			local par_it = find_func_head+1 while par_it <= #pre_stack do
				tail_data = mw.ustring.format("%s %s",tail_data,_item_tostring(pre_stack[par_it]))
				par_it = par_it + 1
			end
			tail_data = mw.ustring.format((par_count==2) and "%s %s" or "(%s %s)",_item_tostring(it),tail_data)
			local head_data = mw.text.trim(par_data[1])
			pre_stack[find_func_head] = (head_data=='' and '' or head_data..' ')..tail_data
			par_it = find_func_head+1 while par_it <= #pre_stack do pre_stack[par_it]=nil end
			cmt_str = ""
			cmt_count=0
		elseif opdata.count == 1 then
			if opdata.count == 1 or cmt_str == "" then
				pre_stack[#pre_stack] = mw.ustring.format("(%s %s)",
					_item_tostring(it),_item_tostring(pre_stack[#pre_stack])
				)
			else
				local oper_out_format = (cmt_count==2) and "%s %s" or "(%s %s)"
				pre_stack[(#pre_stack<=0 and 0 or #pre_stack) + 1] = mw.ustring.format(oper_out_format,
					_item_tostring(it),_item_tostring(cmt_str)
				)
			end
			cmt_str = ""
			cmt_count=0
		elseif opdata.count == 2 then
		--case 2元運算子
			if #pre_stack == 1 and cmt_str ~= "" then
				local oper_out_format = (cmt_count==2) and "%s %s , %s" or ((cmt_count==1) and "%s %s %s" or "%s %s (, %s)")
				pre_stack[#pre_stack] = mw.ustring.format(oper_out_format,
					_item_tostring(it),
					_item_tostring(pre_stack[#pre_stack]),
					_item_tostring(cmt_str)
				)
				cmt_str = ""
				cmt_count=0
			else
				pre_stack[#pre_stack-1] = mw.ustring.format("%s %s %s",
					_item_tostring(it),
					_item_tostring(pre_stack[#pre_stack-1]),
					_item_tostring(pre_stack[#pre_stack])
				)
				pre_stack[#pre_stack] = nil
			end
		elseif it.propetry == "operator" then
		elseif it.name == "$END" then
		--case 結尾
			tail_process()
		else--otherwise
			pre_stack[#pre_stack+1] = it
		end
	end
	tail_process()

	local result = mw.text.trim(_item_tostring(pre_stack[1]) or _item_tostring(pre_stack[0]))
	if mw.ustring.sub(result,1,1) == '(' and mw.ustring.sub(result,-1,-1) == ')' then result = mw.ustring.sub(result,2,-2) end
	result = mw.text.split(mw.ustring.gsub(result,'%s+',' '),'%s+')
	for i, result_str in pairs( result ) do
		if mw.text.trim(result_str) ~= '|' then
			body = body .. mw.ustring.gsub(format, "%%s", result_str) 
		end
	end
	body = mw.ustring.gsub(body,"⇽","←") 
	return body
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,true,function(msg)mw.log("錯誤! "..msg)end))
-- 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,true,function(msg)mw.log("錯誤! "..msg)end))
-- 217.146633205
--mw.log(p.calc("(i*j*k)",require("Module:Complex Number").qmath.init(),require("Module:Complex Number").qmath.init().toQuaternionNumber,true,true,function(msg)mw.log("錯誤! "..msg)end))
-- (-1)
function p.calc(input_str, math_lib, number_Constructer, debug_flag, should_use_other_module, error_func)
	if comp_number == nil then comp_number = require("Module:Complex Number") end
	if should_use_other_module ~= nil then 
		p.use_other_module = not (not should_use_other_module)
	end
	math = comp_number.math.init()
	local mathlib, numberConstructer = math_lib or math, number_Constructer or tonumber
	local adj_input_str = input_str
	if math_lib and math_lib.is_bool_lib == true then adj_input_str = mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(' ' .. input_str .. ' ',"%s+and%s+"," * "),"[&∧]","*"),"%s+or%s+"," + "),"∨","+"),"%s+not%s+"," - "),"¬","-") end
	local pre_expr, pre_scope = p._function_preprocessing(adj_input_str, math_lib, number_Constructer, debug_flag)
	local postfix = p.infixToPostfix(pre_expr, debug_flag)
	if pre_scope then postfix.scope = pre_scope end
	return p.calc_by_postfix(postfix, {}, math_lib, number_Constructer, debug_flag, error_func)
end

function p.nocalc(input_str, math_lib, number_Constructer, debug_flag)
	if comp_number == nil then comp_number = require("Module:Complex Number") end
	math = comp_number.math.init()
	local mathlib, numberConstructer = math_lib or math, number_Constructer or tonumber
	local adj_input_str = input_str
	if math_lib and math_lib.is_bool_lib == true then adj_input_str = mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(mw.ustring.gsub(' ' .. input_str .. ' ',"%s+and%s+"," * "),"[&∧]","*"),"%s+or%s+"," + "),"∨","+"),"%s+not%s+"," - "),"¬","-") end
	return p.infixToPostfix(adj_input_str, debug_flag)
end

local returnMeta = {
	__tostring = function (this) 
		return tostring(this.value)
	end
}
local keep_string = {object=true, ['string']=true, frameArg=true}
local without_load = {object=true, ['string']=true, symbols=true}
function p.calc_by_postfix(postfix, scope, math_lib, number_Constructer, debug_flag, _error_func)
	local error_func = error
	if type(_error_func)==type(noop_func) then error_func = _error_func end
	if comp_number == nil then comp_number = require("Module:Complex Number") end
	math = comp_number.math.init()
	local mathlib, numberConstructer = math_lib or math, number_Constructer or tonumber
	local local_scope = {}
	local call_stack = {{}}
	local calc_stack = {}
	local dbg_func, do_dbg = mw.log, true
	if debug_flag ~= true then dbg_func, do_dbg = noop_func,false end
	
	if type(postfix.scope) == type({}) then for pk, pv in pairs(postfix.scope) do scope[pk] = scope[pk] or postfix.scope[pk]end end
	
	if postfix.is_error == true then error_func("計算失敗："..postfix.error_message, 2) end
	
	for i = 1,#postfix do
		local it = postfix[i]
		if it.propetry == "func start" then
			call_stack[#call_stack + 1] = {}
		elseif it.propetry == "operator" then
			local opdata = p.symbol_table[it.name]
			local to_ass
			local if_return = false
			xpcall(function()
				if it.name == ',' then
					if calc_stack[#calc_stack-1] ~= ',' and calc_stack[#calc_stack] ~= ',' and #(call_stack[#call_stack]) > 0 then call_stack[#call_stack+1]={} end
					if calc_stack[#calc_stack-1] == ',' and calc_stack[#calc_stack] == ',' then
						local call_stack_top_left,call_stack_top_right = {},{}
						for ij = 1, #(call_stack[#call_stack-1]) do call_stack_top_left[#call_stack_top_left + 1] = (call_stack[#call_stack-1])[ij] end
						for ij = 1, #(call_stack[#call_stack]) do call_stack_top_right[#call_stack_top_right + 1] = (call_stack[#call_stack])[ij] end
						local cma_result_left,cma_result_right = p.symbol_table[','].calc( mathlib, unpack( call_stack_top_left ) ), p.symbol_table[','].calc( mathlib, unpack( call_stack_top_right ) )
						call_stack[#call_stack] = nil
						call_stack[#call_stack] = nil
						local call_stack_count = #call_stack
						for queue_it = call_stack_count,1,-1 do call_stack[queue_it+1]=call_stack[queue_it]end
						call_stack[1] = { cma_result_left, cma_result_right }
					else
						if calc_stack[#calc_stack-1] ~= ',' then 
							local call_stack_count = #(call_stack[#call_stack])
							for queue_it = call_stack_count,1,-1 do (call_stack[#call_stack])[queue_it+1]=(call_stack[#call_stack])[queue_it]end
							(call_stack[#call_stack])[1] = calc_stack[#calc_stack-1] 
							--(call_stack[#call_stack])[#(call_stack[#call_stack]) + 1] = calc_stack[#calc_stack-1] 
						end 
						if calc_stack[#calc_stack] ~= ',' then (call_stack[#call_stack])[#(call_stack[#call_stack]) + 1] = calc_stack[#calc_stack] end 
					end
					calc_stack[#calc_stack] = nil; calc_stack[#calc_stack] = ','
				elseif opdata.count == 1 then
					if calc_stack[#calc_stack] == ',' and #call_stack > 0 then
						local call_stack_top = {}
						for ij = 1, #(call_stack[#call_stack]) do call_stack_top[#call_stack_top + 1] = (call_stack[#call_stack])[ij] end
						local cma_result = p.symbol_table[','].calc( mathlib, unpack( call_stack_top ) )
						calc_stack[#calc_stack] = opdata.calc(cma_result,mathlib,numberConstructer)
						call_stack[#call_stack] = calc_stack[#calc_stack]
					elseif it.name == '⟵' and type(mathlib.mathdef) ~= type(noop_func) then
						calc_stack = { {
							['return'] = true,
							value=opdata.calc(calc_stack[#calc_stack],mathlib,numberConstructer)
						} }
						setmetatable(calc_stack[1],returnMeta)
						if_return = true
					else
						if ((type(calc_stack[#calc_stack]) == type({})) and calc_stack[#calc_stack] or {}).assign == "assign" then
							local get_data = (local_scope or {})[calc_stack[#calc_stack][1]]
							if get_data then calc_stack[#calc_stack] = local_scope[calc_stack[#calc_stack][1]] 
							error_func("計算失敗：未知的變數 \"" .. _subst_error_strip(tostring(calc_stack[#calc_stack][1])) .. "\" ",2) end
						end
						calc_stack[#calc_stack] = opdata.calc(calc_stack[#calc_stack],mathlib,numberConstructer)
					end
				else
					if it.name ~= '←' then
						if ((type(calc_stack[#calc_stack]) == type({})) and calc_stack[#calc_stack] or {}).assign == "assign" then
							local get_data = (local_scope or {})[calc_stack[#calc_stack][1]]
							if get_data then calc_stack[#calc_stack] = local_scope[calc_stack[#calc_stack][1]] 
							else 
								local try_scope_obj = calc_stack[#calc_stack][1]
								local try_scope_name = tostring(try_scope_obj)
								local try_scope = mathlib[try_scope_name]
								if type(try_scope_obj) == type({}) and try_scope_obj.isObject then try_scope = try_scope_obj.value or try_scope end
								if try_scope==nil then try_scope = scope[try_scope_name] end
								if try_scope==nil then try_scope = _G[try_scope_name] end
								if try_scope==nil and mathlib.noncalculate ~= true and mathlib.ext_loaded ~= true then
									mathlib = ext_mathlib(mathlib, numberConstructer)
									try_scope = mathlib[try_scope_name]
									if use_ext_mathlib ~= true then use_ext_mathlib = true end
								end
								if try_scope~=nil then 
									if type(try_scope)==type(noop_func) then	calc_stack[#calc_stack] = try_scope_name
									else calc_stack[#calc_stack] = try_scope end
								else error_func("計算失敗：未知的變數 \"" .. _subst_error_strip(tostring(calc_stack[#calc_stack][1])) .. "\" " ,2) end
							end
						end
						if ((type(calc_stack[#calc_stack - 1]) == type({})) and calc_stack[#calc_stack - 1] or {}).assign == "assign" then
							local get_data = (local_scope or {})[calc_stack[#calc_stack - 1][1]]
							if get_data then calc_stack[#calc_stack - 1] = local_scope[calc_stack[#calc_stack - 1][1]] 
							else
								local try_scope_obj = calc_stack[#calc_stack - 1][1]
								local try_scope_name = tostring(try_scope_obj)
								local try_scope = mathlib[try_scope_name]
								if type(try_scope_obj) == type({}) and try_scope_obj.isObject then try_scope = try_scope_obj.value or try_scope end
								if try_scope==nil then try_scope = scope[try_scope_name] end
								if try_scope==nil then try_scope = _G[try_scope_name] end
								if try_scope==nil and mathlib.noncalculate ~= true and mathlib.ext_loaded ~= true then
									mathlib = ext_mathlib(mathlib, numberConstructer)
									try_scope = mathlib[try_scope_name]
									if use_ext_mathlib ~= true then use_ext_mathlib = true end
								end
								if try_scope~=nil then calc_stack[#calc_stack - 1] = try_scope
								else error_func("計算失敗：未知的變數 \"" .. _subst_error_strip(tostring(calc_stack[#calc_stack - 1][1])) .. "\" ",2) end
							end
						end
					else
						if ((type(calc_stack[#calc_stack]) == type({})) and calc_stack[#calc_stack] or {}).assign == "assign" then
							local get_data = (local_scope or {})[calc_stack[#calc_stack][1]]
							if get_data then calc_stack[#calc_stack] = local_scope[calc_stack[#calc_stack][1]] 
							else get_data = (scope or {})[calc_stack[#calc_stack][1]] or _G[calc_stack[#calc_stack][1]] or mathlib[calc_stack[#calc_stack][1]]
								if type(get_data) == type(noop_func) then calc_stack[#calc_stack] = get_data
								else error_func("計算失敗：未知的變數 \"" .. _subst_error_strip(tostring(calc_stack[#calc_stack][1])) .. "\" ",2) end
							end
						end
						to_ass = calc_stack[#calc_stack - 1]
					end
					if (calc_stack[#calc_stack] == ',' or calc_stack[#calc_stack-1] == ',') and #call_stack > 0 then
						
						local cma_result_left,cma_result_right
						if calc_stack[#calc_stack-1] == ',' and calc_stack[#calc_stack] == ',' then
							local call_stack_top_left,call_stack_top_right = {},{}
							for ij = 1, #(call_stack[#call_stack-1]) do call_stack_top_left[#call_stack_top_left + 1] = (call_stack[#call_stack-1])[ij] end
							for ij = 1, #(call_stack[#call_stack]) do call_stack_top_right[#call_stack_top_right + 1] = (call_stack[#call_stack])[ij] end
							cma_result_left,cma_result_right = p.symbol_table[','].calc( mathlib, unpack( call_stack_top_left ) ), p.symbol_table[','].calc( mathlib, unpack( call_stack_top_right ) )
							calc_stack[#calc_stack - 1] = opdata.calc(cma_result_left ,cma_result_right, mathlib,numberConstructer)
							call_stack[#call_stack] = nil call_stack[#call_stack] = nil
							local call_stack_count = #call_stack
							for queue_it = call_stack_count,1,-1 do call_stack[queue_it+1]=call_stack[queue_it]end
							call_stack[1] =  calc_stack[#calc_stack - 1]
						else
							cma_result_left,cma_result_right = calc_stack[#calc_stack - 1]or 0, calc_stack[#calc_stack]or 0
							local call_stack_top = {}
							for ij = 1, #(call_stack[#call_stack]) do call_stack_top[#call_stack_top + 1] = (call_stack[#call_stack])[ij] end
							local cma_result = p.symbol_table[','].calc( mathlib, unpack( call_stack_top ) )
							if calc_stack[#calc_stack-1] == ',' then cma_result_left = cma_result
							elseif calc_stack[#calc_stack] == ',' then cma_result_right = cma_result end 
							calc_stack[#calc_stack - 1] = opdata.calc(cma_result_left ,cma_result_right, mathlib,numberConstructer)
							call_stack[#call_stack] = nil
							local call_stack_count = #call_stack
							for queue_it = call_stack_count,1,-1 do call_stack[queue_it+1]=call_stack[queue_it]end
							call_stack[1] =  calc_stack[#calc_stack - 1]
						end
					else
						calc_stack[#calc_stack - 1] = opdata.calc(calc_stack[#calc_stack - 1]or 0 ,calc_stack[#calc_stack]or 0,mathlib,numberConstructer)
					end
					calc_stack[#calc_stack] = nil
				end
			end, function(message)
				error_func("計算失敗：套用運算子 \"" .. _subst_error_strip(mw.text.trim(it.name)) .. "\" 發生錯誤 \"" .. message .. "\" ",2)
			end)
			xpcall(function() (calc_stack[#calc_stack]):clean() end,function(_)end)
			if it.name == '←' and type(mathlib.mathdef) ~= type(noop_func)then
				local cantass = "計算失敗：套用運算子 \"" .. _subst_error_strip(mw.text.trim(it.name)) .. "\" 發生錯誤：無法將 \"".. tostring(to_ass[1] or to_ass) .."\" 的值設定為 \"" .. tostring(calc_stack[#calc_stack] ) .. "\" "
				local check_num = numberConstructer(to_ass[1] or to_ass)
				if check_num then error_func(cantass,2) elseif local_scope then local_scope[to_ass[1]] = calc_stack[#calc_stack] else error_func(cantass,2)end
			end
			if do_dbg == true then dbg_func(it.name, '\t', print_sk(calc_stack,', ') ) end
			if if_return then break end
		elseif it.propetry == "func" then
			local calfunc, functype = mathlib[it.name], type(noop_func)
			if type(calfunc) ~= functype and type((scope or {})[it.name]) == functype then calfunc = scope[it.name] end
			if type(calfunc) ~= functype and type(_G[it.name]) == functype then calfunc = _G[it.name] end
			if type(calfunc) ~= functype and mathlib.noncalculate ~= true and mathlib.ext_loaded ~= true then
				mathlib = ext_mathlib(mathlib, numberConstructer)
				calfunc = mathlib[it.name]
				if use_ext_mathlib ~= true and type(calfunc) == functype then use_ext_mathlib = true end
			end
			if type(calfunc) ~= functype and type((local_scope or {})[it.name]) == functype then calfunc = local_scope[it.name] end
			local is_other_module = false
			if type(calfunc) ~= functype and p.use_other_module == true then
				local check_func = mw.text.split(it.name,"AtModule")
				if #check_func > 1 then
					xpcall(function() 
						local load_module = require( "Module:" .. check_func[2])
						calfunc = load_module[check_func[1]]
						is_other_module = true
					end, function(message)
						error_func("計算失敗：執行函數 \"" .. "Module:" .. check_func[2] .. '#' .. check_func[1] .. "\" 發生錯誤 \"" .. message .. "\" ",2)
					end)
				end
			end
			local callstr = it.name
			local ifreturn = false
			if type(calfunc) == functype then
				xpcall(function() 
					local call_stack_top = {}
					for j = 1, #(call_stack[#call_stack]) do 
						if ((type((call_stack[#call_stack])[j] ) == type({})) and (call_stack[#call_stack])[j] or {}).assign == "assign" then
							local get_data = (local_scope or {})[(call_stack[#call_stack])[j][1]]
							if get_data then (call_stack[#call_stack])[j]  = local_scope[(call_stack[#call_stack])[j][1]] 
							else 
								local try_scope_obj = (call_stack[#call_stack])[j][1]
								local try_scope_name = tostring(try_scope_obj)
								local try_scope = mathlib[try_scope_name]
								if without_load[callstr] then try_scope = try_scope_obj end
								if type(try_scope_obj) == type({}) and try_scope_obj.isObject then try_scope = try_scope_obj.value or try_scope end
								if try_scope==nil then try_scope = scope[try_scope_name] end
								if try_scope==nil then try_scope = _G[try_scope_name] end
								if try_scope==nil and mathlib.noncalculate ~= true and mathlib.ext_loaded ~= true then
									mathlib = ext_mathlib(mathlib, numberConstructer)
									try_scope = mathlib[try_scope_name]
									if use_ext_mathlib ~= true then use_ext_mathlib = true end
								end
								if try_scope~=nil then (call_stack[#call_stack])[j] = try_scope
								else error_func("計算失敗：未知的變數 \"" .. _subst_error_strip(tostring((call_stack[#call_stack])[j][1])) .. "\" ",2) end
							end
						end
						call_stack_top[#call_stack_top + 1] = (call_stack[#call_stack])[j] 
					end
					if call_stack_top == ',' or call_stack_top == '' or call_stack_top == nil then 
						call_stack_top[#call_stack_top + 1] = calc_stack[#calc_stack]
					end
					if #call_stack_top > 0 then
						if do_dbg == true then callstr = callstr .. '(' .. print_sk(call_stack_top,',') .. ')' end
						local wrap_call_stack_top = call_stack_top
						if is_other_module then
							wrap_call_stack_top = {}
							for k,v in pairs(call_stack_top) do wrap_call_stack_top[k] = tostring(v) end
						end
						local calc_result = calfunc( unpack( wrap_call_stack_top ) )
						if type(calc_result) == type({}) and calc_result['return'] then
							calc_result = calc_result.value
							if type(mathlib.mathdef) ~= type(noop_func) then
								calc_stack = {calc_result}
								ifreturn = true
							end
						end
						if type(calc_result) == type('') and (not keep_string[callstr]) then 
							calc_result = numberConstructer(calc_result) or calc_result
						end
						calc_stack[#calc_stack] = calc_result
					else
						if ((type(calc_stack[#calc_stack]) == type({})) and calc_stack[#calc_stack] or {}).assign == "assign" then
							local get_data = (local_scope or {})[calc_stack[#calc_stack][1]]
							if get_data then calc_stack[#calc_stack] = local_scope[calc_stack[#calc_stack][1]] 
							else 
								local try_scope_obj = calc_stack[#calc_stack][1]
								local try_scope_name = tostring(try_scope_obj)
								local try_scope = mathlib[try_scope_name]
								if without_load[callstr] then try_scope = try_scope_obj end
								if type(try_scope_obj) == type({}) and try_scope_obj.isObject then try_scope = try_scope_obj.value or try_scope end
								if try_scope==nil then try_scope = scope[try_scope_name] end
								if try_scope==nil then try_scope = _G[try_scope_name] end
								if try_scope==nil and mathlib.noncalculate ~= true and mathlib.ext_loaded ~= true then
									mathlib = ext_mathlib(mathlib, numberConstructer)
									try_scope = mathlib[try_scope_name]
									if use_ext_mathlib ~= true then use_ext_mathlib = true end
								end
								if try_scope~=nil then calc_stack[#calc_stack] = try_scope
								else error_func("計算失敗：未知的變數 \"" .. _subst_error_strip(tostring(calc_stack[#calc_stack][1])) .. "\" ",2) end
							end
						end
						local wrap_call_stack_top = calc_stack[#calc_stack]
						if is_other_module then wrap_call_stack_top = tostring(wrap_call_stack_top) end
						local calc_result = calfunc( wrap_call_stack_top )
						if type(calc_result) == type({}) and calc_result['return'] then
							calc_result = calc_result.value
							if type(mathlib.mathdef) ~= type(noop_func) then
								calc_stack = {calc_result}
								ifreturn = true
							end
						end
						if type(calc_result) == type('') and (not keep_string[callstr]) then 
							calc_result = numberConstructer(calc_result) or calc_result
						end
						calc_stack[#calc_stack] = calc_result
					end
					call_stack[#call_stack] = nil
				end, function(message)
					error_func("計算失敗：執行函數 \"" .. _subst_error_strip(it.name) .. "\" 發生錯誤 \"" .. message .. "\" ",2)
				end)
			else
				if it.name == '(' then error_func("計算失敗：未封閉的括號",2) end
				error_func("計算失敗：無法執行函數 \"" .. _subst_error_strip(it.name) .. "\" ",2)
			end
			xpcall(function() (calc_stack[#calc_stack]):clean() end,function(_)end)
			if do_dbg == true then dbg_func(callstr, '\t', print_sk(calc_stack,', ') ) end
			if ifreturn then break end
		else
			local get_data = numberConstructer(it.name)
			if get_data == nil then get_data = numberConstructer((scope or {})[it.name]) or numberConstructer(_G[it.name]) or numberConstructer(mathlib[it.name]) or numberConstructer(it.name) end
			if get_data == nil then get_data={it.name,assign="assign"}end
			calc_stack[#calc_stack + 1] = get_data
			xpcall(function() (calc_stack[#calc_stack]):clean() end,function(_)end)
			if do_dbg == true then dbg_func(it.name, '\t', print_sk(calc_stack,', ') ) end
		end
	end
	if #calc_stack == 1 then 
		local checker = calc_stack[#calc_stack]
		if ((type(calc_stack[#calc_stack]) == type({})) and calc_stack[#calc_stack] or {}).assign == "assign" then
			checker = tostring(calc_stack[#calc_stack][1])
		end
		if checker == ',' then
			for call_i=#call_stack,1,-1 do
				for call_j=1,#(call_stack[call_i]) do
					if ((type(call_stack[call_i][call_j]) == type({})) and call_stack[call_i][call_j] or {}).assign == "assign" then
						local get_data = (local_scope or {})[call_stack[call_i][call_j][1]]
						if get_data then call_stack[call_i][call_j] = local_scope[call_stack[call_i][call_j][1]] 
						else call_stack[call_i][call_j] = tostring(call_stack[call_i][call_j][1]) end
					end
					if checker == ',' then checker = '' else checker = checker..', ' end
					checker = checker .. tostring(call_stack[call_i][call_j])
				end
			end
		end
		return checker
	elseif #calc_stack > 1 then 
		local check_number_data = print_sk(calc_stack,', ')
		if mw.text.trim(check_number_data) == '' then
			error_func("計算失敗：缺少運算子和運算數，無法運算",2)
		elseif not mw.ustring.find(check_number_data,',') then
			--"缺少運算子且只有一個運算數" 那就返回運算數，不視為錯誤
			--error_func("計算失敗：預期為二元運算，但缺少運算子且只有一個運算數 \"".. check_number_data .."\"，無法運算",2)
			return numberConstructer(check_number_data)
		else
			error_func("計算失敗：缺少運算子，數字 [" .. check_number_data .. "] 無法運算",2)
		end
	end
	return numberConstructer(0)
end

function p.infixToPostfix(input_str, debug_flag)
	local str, index, num_list = input_str, 0, {}; 
	local dbg_func, do_dbg = mw.log, true
	if debug_flag ~= true then dbg_func, do_dbg = noop_func,false end
	local flag_logging = {}
	local flag_logging_list = {
		logic_func = "replace logic operators...",
		round_and_return = "replace round and return operators...",
		equal_operator = "replace equal operators...",
		scientific = "replace scientific symbols...",
		imaginary_unit = "replace imaginary units..."
	}
	if mw.ustring.find(str,"[xXnN]?[aAoOnN][nNrRoO][dDtTrR]?([^%a%(])") then
		str = mw.ustring.gsub(str,"([%A])[aA][nN][dD]([^%a%(])","%1 & %2")
		str = mw.ustring.gsub(str,"([%A])[nN][aA][nN][dD]([^%a%(])","%1 ↑ %2")

		str = mw.ustring.gsub(str,"([%A])[oO][rR]([^%a%(])","%1 | %2")
		str = mw.ustring.gsub(str,"([%A])[nN][oO][rR]([^%a%(])","%1 ↓ %2")

		str = mw.ustring.gsub(str,"([%A])[xX][oO][rR]([^%a%(])","%1 ⊕ %2")
		str = mw.ustring.gsub(str,"([%A])[xX][nN][oO][rR]([^%a%(])","%1 ⇔ %2")

		str = mw.ustring.gsub(str,"([%A])[nN][oO][tT]([^%a%(])","%1 ~ %2")
		str = mw.ustring.gsub(str,"^not([^%a%(])","~ %1")
		flag_logging.logic_func = true
	end
	if mw.ustring.find(str,"[rR][oOeE][uUtT][nNuU][dDrR][nN]?([^%a%(])") then
		str = mw.ustring.gsub(str,"([%A])[rR][oO][uU][nN][dD]([^%a%(])","%1 ≃ %2")
		str = mw.ustring.gsub(str,"([%A])[rR][eE][tT][uU][rR][nN]([^%a%(])","%1 ⟵ %2")
		str = mw.ustring.gsub(str,"^%s*[rR][eE][tT][uU][rR][nN]([^%a%(])","⟵ %1")
		flag_logging.round_and_return = true
	end
	local feq1,feq2,fsci,fsi,fsj,fsk,fpi,fpj,fpk = 0,0,0,0,0,0,0,0,0
	str, feq1 = mw.ustring.gsub(str,"([><=!~@])=",function(str) return ({['>']='≥',['<']='≤',['~']='≠',['!']='≠',['=']='=',['@']='←'})[str] end)
	str, feq2 = mw.ustring.gsub(str,"([%a%d]+)%s*([%+%-−%*×⋅/÷%%%^&↑%|↓⊕⇔])=", "%1 ← %1 %2 ")
	str, fsci = mw.ustring.gsub(str,"([%+%-]?)(%d*%.?%d+)e([%+%-]?%d+)([ijk]?)",function(n_sign,n_num,n_pow,ijk) return n_sign.."("..n_num.."*10^("..n_pow.."))"..((ijk~=nil and ijk~='')and(' ˙ '..ijk) or'') end)

	if mw.ustring.find(str,"[ijk]") then
		str, fsi = mw.ustring.gsub(str,"(%a)i","%1I")
		str, fsj = mw.ustring.gsub(str,"(%a)j","%1J")
		str, fsk = mw.ustring.gsub(str,"(%a)k","%1K")
		str, fpi = mw.ustring.gsub(str,"i(%a)","I%1")
		str, fpj = mw.ustring.gsub(str,"j(%a)","J%1")
		str, fpk = mw.ustring.gsub(str,"k(%a)","K%1")
	end
	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 
	); 
	if ((fpi or 0)+(fsi or 0)) ~= 0 then result = mw.ustring.gsub(result,"I","i") end
	if ((fpj or 0)+(fsj or 0)) ~= 0 then result = mw.ustring.gsub(result,"J","j") end
	if ((fpk or 0)+(fsk or 0)) ~= 0 then result = mw.ustring.gsub(result,"K","k") end
	--------------------------------------------------------
	if do_dbg then
		if ((feq1 or 0)+(feq2 or 0)) ~= 0 then flag_logging.equal_operator = true end
		if (fsci or 0) ~= 0 then flag_logging.scientific = true end
		if ((fpi or 0)+(fsi or 0)+(fpj or 0)+(fsj or 0)+(fpk or 0)+(fsk or 0)) ~= 0 then flag_logging.imaginary_unit = true end
		for flag_name,flag in pairs(flag_logging)do if flag == true and flag_logging_list[flag_name] then dbg_func(flag_logging_list[flag_name])end end 
	end
	--------------------------------------------------------
	local str2, index, azid, func_list = result, 0, '', {}; 
	local result = mw.ustring.gsub(str2,"[π°]",
		function(b) 
			if b ~= nil and mw.text.trim(b) ~= '' then 
				num_list[#num_list + 1] = b 
				return ' ˙ ' .. tostring(#num_list) .. ' '
			end
		end
	);
	result = mw.ustring.gsub(result,"%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
	if do_dbg then dbg_func(mw.ustring.format('result string is "%s"', result)) 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
				local psymbol_tablestackstacknamecount,_fl = -1
				_fl,psymbol_tablestackstacknamecount = xpcall(function()return p.symbol_table[stack[#stack].name].count end,noop_func)
				if (stack[#stack] or {elements=0}).elements < (psymbol_tablestackstacknamecount or -1) then
					local error_message = p.symbol_table[stack[#stack].name].name.."運算子需要"..p.symbol_table[stack[#stack].name].count.."個運算數，但只找到"..stack[#stack].elements.."個運算數"
					if do_dbg == true then dbg_func("== \""..stack[#stack].name.."\" "..error_message) end
					return {is_error=true, error_message=error_message}
				end
				postfix[#postfix + 1] = {name=stack[#stack].name, propetry=stack[#stack].propetry}
				stack[#stack] = nil --pop
				if stack[#stack] then stack[#stack].elements = (stack[#stack].elements or 0) + 1 end
			end
			if do_dbg == true then dbg_func("結束",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack)) end
		elseif mw.ustring.match(it,"[%a%(]") then
			stack[#stack + 1] = {name=it,elements=0,propetry='func'}
			if do_dbg == true then dbg_func(it, "括號開始",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack)) end
			if func_list[it] ~= nil then postfix[#postfix + 1] = {name=' ', propetry="func start"} end
		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]or{name=noop_func}).name] and p.symbol_table[(stack[#stack]or{name=noop_func}).name].priority and
					p.symbol_table[stack[#stack].name].ppriority >= p.symbol_table[it].priority do
						if stack[#stack].elements < p.symbol_table[stack[#stack].name].count then
							local error_message = p.symbol_table[stack[#stack].name].name.."運算子需要"..p.symbol_table[stack[#stack].name].count.."個運算數，但只找到"..stack[#stack].elements.."個運算數"
							if do_dbg == true then dbg_func("== \""..stack[#stack].name.."\" "..error_message) end
							return {is_error=true, error_message=error_message}
						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
			if do_dbg == true then dbg_func(it, "運算子",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack)) end
		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
			if do_dbg == true then dbg_func(it, "數字",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack)) end
		elseif it == ')' then
			local flag = mw.ustring.match(stack[#stack].name,"[%a%(]")
			while flag == nil do --遇 ) 輸出至 ( 
				if stack[#stack].name ~= "$END" then 
					if stack[#stack].elements < p.symbol_table[stack[#stack].name].count then
						local error_message = p.symbol_table[stack[#stack].name].name.."運算子需要"..p.symbol_table[stack[#stack].name].count.."個運算數，但只找到"..stack[#stack].elements.."個運算數"
						if do_dbg == true then dbg_func("== \""..stack[#stack].name.."\" "..error_message) end
						return {is_error=true, error_message=error_message}
					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
				flag = mw.ustring.match(stack[#stack].name,"[%a%(]")
			end
			if mw.ustring.match(stack[#stack].name,"%a") then
				if stack[#stack].name ~= "$END" then 
					postfix[#postfix + 1] = {name=func_list[stack[#stack].name] or stack[#stack].name, propetry=stack[#stack].propetry}
				end
			end
			if stack[#stack].name == "$END" then 
				local error_message = "未預料的反括號"
				if do_dbg == true then dbg_func("=="..error_message) end
				postfix.is_error=true
				postfix.error_message = error_message
			else
				stack[#stack] = nil --pop
			end
			if stack[#stack] then stack[#stack].elements = ((stack[#stack] or {}).elements or 0) + 1 end
			if do_dbg == true then dbg_func(it, "結束括號",'\t', print_sk(postfix,' ') ,'\t',print_sk(stack))end
		end
	end

	return postfix

end

function p.ifNumeric(frame)
	local result, can_math, should_math, input_math_lib, input_to_number
	local error_count = 0
	local error_flag = xpcall(function()
		result, can_math, should_math, input_math_lib, input_to_number = p._preCalculate(frame, function()error_count = error_count + 1 end)
	end,noop_func)
	error_flag = (not error_flag) or (error_count > 0)
    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 = getArgs(frame) --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 body = ''
    if args[2]==nil and args[3]==nil then return error_flag and '' or '1' end
    if error_flag then
    	body = args[3] or body
    else
    	body = args[2] or body
    end
	return body
end

function p.calcExpr(frame)
	local result, can_math, should_math, input_math_lib, input_to_number
	local error_count = 0
	local bool_value = 0
	local error_message
	local error_flag = xpcall(function()
		result, can_math, should_math, input_math_lib, input_to_number = p._preCalculate(frame, function(msg)
			error_message = error_message or msg
			error_count = error_count + 1 
		end)
		bool_value = input_math_lib.abs(result)
	end,noop_func)
	error_flag = (not error_flag) or (error_count > 0)
    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 = getArgs(frame) --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 body = ''
    if args[2]==nil and args[3]==nil then 
    	if error_message~=nil and error_flag then error(error_message, 2) end
    	return result
    end
    if bool_value > 1e-14 and (not error_flag) then
    	body = args[2] or body
    else
    	body = args[3] or body
    end
	return body
end

function p.isReal(frame)
    local args
	local result, can_math, should_math, input_math_lib, input_to_number
	local error_count = 0
	local non_real_value = 0
	local error_flag = xpcall(function()
		result, can_math, should_math, input_math_lib, input_to_number = p._preCalculate(frame, function()error_count = error_count + 1 end)
		non_real_value = input_math_lib.abs(input_math_lib.nonRealPart(result))
	end,noop_func)
	error_flag = (not error_flag) or (error_count > 0)
    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 = getArgs(frame) --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 body = ''
    if non_real_value > 1e-14 or error_flag then
    	body = args[3] or body
    else
    	body = args[2] or body
    end
	return body
end

--表達式輸出為<math></math>支援
p.tagmath={
	matheq=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'=','=')
	end,
	mathneq=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'≠','\\neq')
	end,
	mathdef=function(op1,op2)
		local that, oper_id = p.tagmath.toTagMath(op2), ''
		if op2.lowoperator ~= '(' and op2.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		return p.tagmath.apply_binary_operator(op1,that,'←','\\overset{\\underset{\\mathrm{def}}{}}{=}')
	end,
	mathmapsto=function(op1,op2)
		local that_op1, oper_id = p.tagmath.toTagMath(op1), ''
		if op1.lowoperator ~= '(' and op1.lowoperator ~= '' then that_op1.value = "\\left( " .. that_op1.value .. "\\right) "end
		that_op1.lowoperator = oper_id
		return p.tagmath.apply_binary_operator(that_op1,op2,'↦','\\mapsto')
	end,
	mathfuncdef=function(op1,op2)
		local that_op1, oper_id = p.tagmath.toTagMath(op1), ''
		that_op1.lowoperator = oper_id
		return p.tagmath.apply_binary_operator(that_op1,op2,':',':')
	end,
	mathset=function(op1,op2)
		local that_op1, oper_id, that = p.tagmath.toTagMath(op1), ''
		if op1.lowoperator ~= '(' and op1.lowoperator ~= '' then that_op1.value = "\\left( " .. that_op1.value .. "\\right) "end
		that_op1.lowoperator = oper_id
		that, oper_id = p.tagmath.toTagMath(op2), ''
		if op2.lowoperator ~= '(' and op2.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		return p.tagmath.apply_binary_operator(that_op1,that,'⇽','\\gets')
	end,
	mathcomma=function(...)
		local get_all_arg = {...}
		if #get_all_arg == 1 then return get_all_arg[1] end
		if #get_all_arg == 0 then return '' end
		local merge_data = ''
		for itj=1,#get_all_arg do
			if merge_data ~= '' then merge_data = merge_data .. ' ,\\, ' end
			merge_data = merge_data .. tostring(get_all_arg[itj])
		end
		local that_op1, oper_id = p.tagmath.toTagMath(merge_data), ''
		that_op1.value = "\\left( " .. that_op1.value .. "\\right) "
		that_op1.lowoperator = oper_id
		return that_op1
	end,
	mathsemicolon=function(op1,op2)
		local check_empty = mw.ustring.gsub(tostring(op1),'%s','')
		if check_empty =="{}" or check_empty == '' then return op2 end
		return p.tagmath.apply_binary_operator(op1,op2,';',';\\,')
	end,
	mathtimes=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'⋅','\\, ')
	end,
	mathlt=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'<','<')
	end,
	mathgt=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'>','>')
	end,
	mathlteq=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'≤','\\leq')
	end,
	mathgteq=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'≥','\\geq')
	end,
	mathand=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'&','\\land')
	end,
	mathnand=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'↑','\\uparrow')
	end,
	mathor=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'|','\\lor')
	end,
	mathnor=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'↓','\\downarrow')
	end,
	mathxor=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'⊕','\\oplus')
	end,
	mathxnor=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'⇔','\\leftrightarrow')
	end,
	mathnot=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		that.value = "\\lnot" .. that.value
		return that 
	end,
	mathreturn=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		that.lowoperator = oper_id
		that.value = "\\text{return}\\," .. that.value
		return that 
	end,
	pow=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'^','^',false,true)
	end,
	div=function(op1,op2)
		local left, right = p.tagmath.toTagMath(op1), p.tagmath.toTagMath(op2)
		left.lowoperator = ''
		left.value = "\\frac{ " .. left.value .. " }{ " .. right.value .. "}"
		return left 
	end,
	sqrt=function(op1,op2)
		local left = p.tagmath.toTagMath(op1)
		if op2 ~= nil then
			local right = p.tagmath.toTagMath(op2)
			left.value = "\\sqrt[ " .. right.value .. " ]{ " .. left.value .. "}"
		else
			left.value = "\\sqrt{ " .. left.value .. " }"
		end
		left.lowoperator = ''
		return left 
	end,
	dot=function(op1,op2)
		return p.tagmath.apply_binary_operator(op1,op2,'*','\\cdot')
	end,
	exp=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		that.lowoperator = oper_id
		that.value = " e^{ " .. that.value .. "} "
		return that 
	end,
	log=function(op1,op2)
		local left, right, vals, log_symbol
		if op2 ~= nil then
			right, left = p.tagmath.toTagMath(op1), p.tagmath.toTagMath(op2)
			vals = "_{" .. right.value .. "}"
			log_symbol = "log " 
		else 
			left, vals = p.tagmath.toTagMath(op1), ''
			log_symbol = "ln "
		end
		if left.lowoperator ~= '(' and left.lowoperator ~= '' then left.value = "\\left( " .. left.value .. "\\right) "end
		left.lowoperator = ''
		left.value = '\\' .. log_symbol .. vals .. left.value
		return left 
	end,
	abs=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		that.lowoperator = oper_id
		that.value = "\\left\\vert " .. that.value .. "\\right\\vert "
		return that 
	end,
	conjugate=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		that.lowoperator = oper_id
		that.value = "\\overline{ " .. that.value .. " } "
		return that 
	end,
	floor=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		that.lowoperator = oper_id
		that.value = "\\left\\lfloor " .. that.value .. "\\right\\rfloor "
		return that 
	end,
	ceil=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		that.lowoperator = oper_id
		that.value = "\\left\\lceil " .. that.value .. "\\right\\rceil "
		return that 
	end,
	binomial=function(n,k)
		local that, oper_id = p.tagmath.toTagMath(n), ''
		local that_k = p.tagmath.toTagMath(k) or {value=''}
		that.lowoperator = oper_id
		that.value = "\\binom {" .. that.value .. "}{" .. that_k.value .. '}'
		return that 
	end,
	min=function(...)
		local this_list, oper_id = {...}, ''
		local that = p.tagmath.toTagMath(this_list[1])
		for i=2,#this_list do
			local it_item = p.tagmath.toTagMath(this_list[i])
			that.value = that.value .. ', \\,' .. it_item.value
		end
		that.value = "\\left( " .. that.value .. "\\right) "
		that.lowoperator = oper_id
		that.value = "\\min {" .. that.value .. '}'
		return that 
	end,
	factorial=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		that.value = that.value .. "!"
		return that 
	end,
	ele=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		that.value = "\\,e_{" .. that.value .. "}"
		return that 
	end,
	norm=function(n,_p)
		local that, oper_id = p.tagmath.toTagMath(n), ''
		local that_p = p.tagmath.toTagMath(_p) or {value=''}
		that.lowoperator = oper_id
		that.value = "\\left \\|" .. that.value .. "\\right \\|"
		if _p then that.value = that.value .."_{" .. that_p.value .. '}' end
		return that 
	end,
	transpose=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		that.value = that.value .. "^{\\mathrm{T}}"
		return that 
	end,
	identity=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		that.lowoperator = oper_id
		that.value = "I_{" .. that.value .. "}"
		return that 
	end,
	row=function(...)
		local get_all_arg = {...}
		if #get_all_arg == 1 then return get_all_arg[1] end
		if #get_all_arg == 0 then return '' end
		local merge_data = ''
		for itj=1,#get_all_arg do
			if merge_data ~= '' then merge_data = merge_data .. ' & ' end
			merge_data = merge_data..'{'..tostring(get_all_arg[itj])..'}'
		end
		local that_op1, oper_id = p.tagmath.toTagMath(merge_data), ''
		that_op1.lowoperator = oper_id
		return that_op1
	end,
	matrix=function(...)
		local get_all_arg = {...}
		if #get_all_arg == 1 then 
			local that_op1, oper_id = p.tagmath.toTagMath(get_all_arg[1]), ''
			that_op1.value = "\\begin{bmatrix} " .. that_op1.value .. "\\end{bmatrix} "
			that_op1.lowoperator = oper_id
			return that_op1
		end
		if #get_all_arg == 0 then return '' end
		local merge_data = ''
		for itj=1,#get_all_arg do
			if merge_data ~= '' then merge_data = merge_data .. ' \\\\\n' end
			merge_data = merge_data .. tostring(get_all_arg[itj])
		end
		local that_op1, oper_id = p.tagmath.toTagMath(merge_data), ''
		that_op1.value = "\\begin{bmatrix} " .. that_op1.value .. "\\end{bmatrix} "
		that_op1.lowoperator = oper_id
		return that_op1
	end,
	mathform=function(inputdata)
		return inputdata
	end,
	cofactor=function(this, p_i, q_j)
		local that, oper_id = p.tagmath.toTagMath(this), '('
		if (this.lowoperator ~= '(') and (this.lowoperator ~= '') then 
			that.value = "\\left( " .. that.value .. "\\right) "
		end
		that.lowoperator = oper_id
		that.value =  '\\mathrm{cof} ' .. that.value

		if p_i~= nil and q_j~= nil then
			local pi_math = p.tagmath.toTagMath(p_i)
			local qj_math = p.tagmath.toTagMath(q_j)
			that.value = "\\left( " .. that.value .. "\\right) _ {{"..pi_math.value.."},\\,{"..qj_math.value.."}}"
		end
		return that 
	end,
	cof=function(this, p_i, q_j)return p.tagmath.cofactor(this, p_i, q_j)end,
	["if"]=function(expr, true_expr, false_expr)
		return p.tagmath._ifelse_func(false, expr, true_expr, false_expr)
	end,
	iff=function(expr, true_expr, false_expr)
		return p.tagmath._ifelse_func(true, expr, true_expr, false_expr)
	end,
	ifelse=function(...)
		return p.tagmath._ifelse_func(false, ...)
	end,
	ifelsef=function(...)
		return p.tagmath._ifelse_func(true, ...)
	end,
	_ifelse_func=function(is_func, ...)
		local exprlist = {...}
		local last_else = #exprlist % 2 == 1
		local max_num = (last_else and (#exprlist - 1) or #exprlist) / 2
		local that, oper_id = p.tagmath.toTagMath(''), ''
		for i=1,max_num do
			if i > 1 then that.value = that.value .. ' \\\\ ' end
			local expr = p.tagmath.toTagMath(exprlist[i * 2 - 1])
			local expr_true = p.tagmath.toTagMath(exprlist[i * 2])
			if is_func then
				expr.value = expr.value:gsub("\\mapsto","")
				expr_true.value = expr_true.value:gsub("\\mapsto","")
			end
			that.value = that.value .. mw.ustring.format("{%s}, & \\text{if }{%s}", expr_true.value, expr.value)
		end
		if last_else then
			local expr_false = p.tagmath.toTagMath(exprlist[#exprlist])
			if is_func then
				expr_false.value = expr_false.value:gsub("\\mapsto","")
			end
			that.value = that.value .. mw.ustring.format(" \\\\ {%s}, & \\text{otherwise}", expr_false.value)
		end
		that.lowoperator = oper_id
		that.value = mw.ustring.format("\\begin{cases} %s \\end{cases}", that.value)
		return that 
	end,
	symbols=function(name)
		local symbolname = p.tagmath.toTagMath(name)
		local symbolresult = require('Module:Complex_Number/Functions')._symbols(mw.text.trim(symbolname.value,"%{%}\t\r\n\f "))
		if symbolresult then
			return p.tagmath.toTagMath(symbolresult)
		end
		return p.tagmath.apply_function("symbols", name)
	end,
	object=function(obj,...)
		local objlist = {...}
		local objname = p.tagmath.toTagMath(obj)
		for i=1,#objlist do
			local to_add = p.tagmath.toTagMath(objlist[i]).value
			if objlist[i].lowoperator ~= '(' and objlist[i].lowoperator ~= '' then to_add = "\\left( " .. to_add .. "\\right) "end
			objname.value = objname.value .. '.' .. to_add
		end
		objname.value = "\\text{" .. objname.value .. "}"
		return objname
	end,
	['string']=function(...)
		local strlist = {...}
		local str = p.tagmath.toTagMath('')
		for i=1,#strlist do
			str.value = str.value .. p.tagmath.toTagMath(strlist[i]).value
		end
		str.value = "{}^\\shortparallel\\text{" .. str.value .. "}^\\shortparallel"
		return str
	end,
	call=function(_func, ...)
		local that_func = p.tagmath.toTagMath(_func)
		local that_args = p.tagmath.mathcomma(...)
		local is_inner_func = mw.ustring.find(tostring(that_func.value),"\\mapsto")
		if #({...}) <= 1 and type(is_inner_func) == type(nil) then that_args.value = "\\left( " .. that_args.value .. "\\right) "end
		if type(is_inner_func) ~= type(nil) then
			that_func.value = that_func.value .. ' \\gets '
		end
		that_args.value = that_func.value..that_args.value
		return that_args
	end,
	diff=function(_expr, _value)
		local that, oper_id = p.tagmath.toTagMath(_value), 'MINOP'
		local that_expr = p.tagmath.toTagMath(_expr)
		local data_start, data_end = mw.ustring.find(tostring(that_expr.value),"\\mapsto")
		local var_data = mw.ustring.sub(tostring(that_expr.value),1,(data_start or 1)-1)
		local expr_data = mw.ustring.sub(tostring(that_expr.value),(data_end or 0)+1,-1)
		var_data = mw.ustring.gsub(var_data,"^%s*%{","")
		expr_data = mw.ustring.gsub(expr_data,"%}%s*$","")
		local group_flag = mw.ustring.find(expr_data,"[%+%-]")
		if not group_flag then
			expr_data = mw.ustring.gsub(expr_data,"\\right%)%s*%}%s*$","")
			expr_data = mw.ustring.gsub(expr_data,"^%s*%{\\left%(","")
		end
		local check_ijk = mw.ustring.find(tostring(var_data),"[ijkIJK]t")
		if (not data_start) or check_ijk then
			var_data = mw.text.trim(var_data) == '' and "x" or var_data
			var_data = mw.ustring.gsub(var_data,"([ijkIJK])t","%1")
			expr_data = mw.ustring.gsub(expr_data,"([ijkIJK])t","%1")
		end
		that.value = mw.ustring.format("\\left.\\frac{d\\,{%s}}{d{%s}}\\right|_{{%s}={%s}}", 
			expr_data, var_data, var_data, that.value)
		that.lowoperator = oper_id
		return that 
	end,
	integral=function(_value, _b, _expr)
		local that, b, oper_id = p.tagmath.toTagMath(_value), p.tagmath.toTagMath(_b), 'MINOP'
		local that_expr = p.tagmath.toTagMath(_expr)
		local data_start, data_end = mw.ustring.find(tostring(that_expr.value),"\\mapsto")
		local var_data = mw.ustring.sub(tostring(that_expr.value),1,(data_start or 1)-1)
		local expr_data = mw.ustring.sub(tostring(that_expr.value),(data_end or 0)+1,-1)
		var_data = mw.ustring.gsub(var_data,"^%s*%{","")
		expr_data = mw.ustring.gsub(expr_data,"%}%s*$","")
		local group_flag = mw.ustring.find(expr_data,"[%+%-]")
		if not group_flag then
			expr_data = mw.ustring.gsub(expr_data,"\\right%)%s*%}%s*$","")
			expr_data = mw.ustring.gsub(expr_data,"^%s*%{\\left%(","")
		end
		local check_ijk = mw.ustring.find(tostring(var_data),"[ijkIJK]t")
		if (not data_start) or check_ijk then
			var_data = mw.text.trim(var_data) == '' and "x" or var_data
			var_data = mw.ustring.gsub(var_data,"([ijkIJK])t","%1")
			expr_data = mw.ustring.gsub(expr_data,"([ijkIJK])t","%1")
		end
		that.value = mw.ustring.format("\\int_{%s}^{%s} %s\\,d{%s}", 
			that.value, b.value, expr_data, var_data)
		that.lowoperator = oper_id
		return that 
	end,
	['∫']=function(_value, _b, _expr)
		return p.tagmath.integral(_value, _b, _expr)
	end,
	limit=function(_value, _way, _expr)
		local that, oper_id = p.tagmath.toTagMath(_value), 'MINOP'
		local check_way = mw.ustring.gsub(tostring(_way),'[\{\}%s]','')
		check_way = tonumber(check_way)
		local way_text = check_way > 1e-8 and "+" or ( check_way < -1e-8 and "-" or '')
		local that_expr = p.tagmath.toTagMath(_expr)
		local data_start, data_end = mw.ustring.find(tostring(that_expr.value),"\\mapsto")
		local var_data = mw.ustring.sub(tostring(that_expr.value),1,(data_start or 1)-1)
		local expr_data = mw.ustring.sub(tostring(that_expr.value),(data_end or 0)+1,-1)
		var_data = mw.ustring.gsub(var_data,"^%s*%{","")
		expr_data = mw.ustring.gsub(expr_data,"%}%s*$","")
		local group_flag = mw.ustring.find(expr_data,"[%+%-]")
		if not group_flag then
			expr_data = mw.ustring.gsub(expr_data,"\\right%)%s*%}%s*$","")
			expr_data = mw.ustring.gsub(expr_data,"^%s*%{\\left%(","")
		end
		local check_ijk = mw.ustring.find(tostring(var_data),"[ijkIJK]t")
		if (not data_start) or check_ijk then
			var_data = mw.text.trim(var_data) == '' and "x" or var_data
			var_data = mw.ustring.gsub(var_data,"([ijkIJK])t","%1")
			expr_data = mw.ustring.gsub(expr_data,"([ijkIJK])t","%1")
		end
		that.value = mw.ustring.format("\\lim_{{%s} \\to {%s}^{%s}}{%s}", var_data, that.value, way_text, expr_data)
		that.lowoperator = oper_id
		return that 
	end,
	summation=function(_begin, _end, _expr)
		local that, oper_id = p.tagmath.toTagMath(_begin), 'MINOP'
		local that_begin = p.tagmath.toTagMath(_begin)
		local that_end = p.tagmath.toTagMath(_end)
		local that_expr = p.tagmath.toTagMath(_expr)
		local data_start, data_end = mw.ustring.find(tostring(that_expr.value),"\\mapsto")
		local var_data = mw.ustring.sub(tostring(that_expr.value),1,(data_start or 1)-1)
		local expr_data = mw.ustring.sub(tostring(that_expr.value),(data_end or 0)+1,-1)
		var_data = mw.ustring.gsub(var_data,"^%s*%{","")
		expr_data = mw.ustring.gsub(expr_data,"%}%s*$","")
		local group_flag = mw.ustring.find(expr_data,"[%+%-]")
		if not group_flag then
			expr_data = mw.ustring.gsub(expr_data,"\\right%)%s*%}%s*$","")
			expr_data = mw.ustring.gsub(expr_data,"^%s*%{\\left%(","")
		end
		local check_ijk = mw.ustring.find(tostring(var_data),"[ijkIJK]t")
		if (not data_start) or check_ijk then
			var_data = mw.text.trim(var_data) == '' and "i" or var_data
			var_data = mw.ustring.gsub(var_data,"([ijkIJK])t","%1")
			expr_data = mw.ustring.gsub(expr_data,"([ijkIJK])t","%1")
		end
		that.value = mw.ustring.format("\\sum_{{%s}={%s}}^{%s} {%s}", var_data, that_begin.value, that_end.value, expr_data)
		that.lowoperator = oper_id
		return that 
	end,
	product=function(_begin, _end, _expr)
		local that, oper_id = p.tagmath.toTagMath(_begin), 'MINOP'
		local that_begin = p.tagmath.toTagMath(_begin)
		local that_end = p.tagmath.toTagMath(_end)
		local that_expr = p.tagmath.toTagMath(_expr)
		local data_start, data_end = mw.ustring.find(tostring(that_expr.value),"\\mapsto")
		local var_data = mw.ustring.sub(tostring(that_expr.value),1,(data_start or 1)-1)
		local expr_data = mw.ustring.sub(tostring(that_expr.value),(data_end or 0)+1,-1)
		var_data = mw.ustring.gsub(var_data,"^%s*%{","")
		expr_data = mw.ustring.gsub(expr_data,"%}%s*$","")
		local group_flag = mw.ustring.find(expr_data,"[%+%-]")
		if not group_flag then
			expr_data = mw.ustring.gsub(expr_data,"\\right%)%s*%}%s*$","")
			expr_data = mw.ustring.gsub(expr_data,"^%s*%{\\left%(","")
		end
		local check_ijk = mw.ustring.find(var_data,"[ijkIJK]t")
		if (not data_start) or check_ijk then
			var_data = mw.text.trim(var_data) == '' and "i" or var_data
			var_data = mw.ustring.gsub(var_data,"([ijkIJK])t","%1")
			expr_data = mw.ustring.gsub(expr_data,"([ijkIJK])t","%1")
		end
		that.value = mw.ustring.format("\\prod_{{%s}={%s}}^{%s} {%s}", var_data, that_begin.value, that_end.value, expr_data)
		that.lowoperator = oper_id
		return that 
	end,
	divisorsigma=function(op1,op2)
		local left, right, vals, sigma_symbol
		right, left = p.tagmath.toTagMath(op1), p.tagmath.toTagMath(op2)
		if op2 == nil then 
			left = p.tagmath.toTagMath("")
			vals = ""
		else
			vals = "_{" .. right.value .. "}"
		end
		sigma_symbol = "sigma "
		left.value = "\\left( " .. ((op2 == nil) and right.value or left.value) .. "\\right) "
		left.lowoperator = ''
		left.value = '\\' .. sigma_symbol .. vals .. left.value
		return left
	end,
	hide=function(this)return""end,
	exprs=function(...)
		local input_args = {...}
		return p.tagmath.mathcomma(unpack(input_args))
	end,
	lastexpr=function(...)
		local input_args = {...}
		return input_args[#input_args]
	end,
	equalexpr=function(...)
		local get_all_arg = {...}
		if #get_all_arg == 1 then return get_all_arg[1] end
		if #get_all_arg == 0 then return '' end
		local merge_data = ''
		for itj=1,#get_all_arg do
			if merge_data ~= '' then merge_data = merge_data .. '=' end
			merge_data = merge_data .. tostring(get_all_arg[itj])
		end
		local that_op1, oper_id = p.tagmath.toTagMath(merge_data), ''
		that_op1.lowoperator = oper_id
		return that_op1
	end,
	inverse=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		that.value = that.value .. "^{-1}"
		return that 
	end,
	re=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		that.value = "\\operatorname{Re}" .. that.value
		return that 
	end,
	im=function(this)
		local that, oper_id = p.tagmath.toTagMath(this), ''
		if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
		that.lowoperator = oper_id
		that.value = "\\operatorname{Im}" .. that.value
		return that 
	end,
	apply_function=function(func_name, ...)
		local para_info = {...}
		local this = #para_info == 1 and para_info[1] or p.tagmath.mathcomma(...)
		local that, oper_id = p.tagmath.toTagMath(this), '('
		local math_ext_funcs={["minimum"]="\\min",["maximum"]="\\max",["sin"]="\\sin",["cos"]="\\cos",["tan"]="\\tan",["sec"]="\\sec",["csc"]="\\csc",["cot"]="\\cot",
			["asin"]="\\arcsin",["acos"]="\\arccos",["atan"]="\\arctan",["asec"]="\\operatorname{arcsec}",["acsc"]="\\operatorname{arccsc}",["acot"]="\\operatorname{arccot}",
			["sinh"]="\\sinh",["cosh"]="\\cosh",["tanh"]="\\tanh",["sech"]="\\operatorname{sech}",["csch"]="\\operatorname{csch}",["coth"]="\\coth",
			["asinh"]="\\operatorname{arcsinh}",["acosh"]="\\operatorname{arccosh}",["atanh"]="\\operatorname{arctanh}",["asech"]="\\operatorname{arcsech}",["acsch"]="\\operatorname{arccsch}",["acoth"]="\\operatorname{arccoth}",
			["scalarPartQuaternion"]="\\operatorname{Scalar}",["vectorPartQuaternion"]="\\operatorname{Vector}",
			["sgn"]="\\sgn",["gamma"]="\\Gamma",["cis"]="\\operatorname{cis}",["eulerphi"]="\\varphi",["LambertW"]="W",
			["gcd"]="\\gcd",["lcm"]="\\operatorname{lcm}",["round"]="\\operatorname{round}",["arg"]="\\arg",["trunc"]="\\operatorname{trunc}",
			["gd"]="\\operatorname{gd}",["arcgd"]="\\operatorname{arcgd}",["cogd"]="\\operatorname{cogd}",
			["diag"]="\\operatorname{diag}",["det"]="\\det",["determinant"]="\\det",
			["adj"]="\\operatorname{adj}",["adjoint"]="\\operatorname{adj}"
		}
		local need_comm={["gamma"]=true,["eulerphi"]=true,["LambertW"]=true}
		local math_format_funcs={
			["factorial"]="%s!"
		}
		if ((#para_info == 1) and (this.lowoperator ~= '(') and (this.lowoperator ~= '')) or
			((#para_info == 1) and (math_ext_funcs[func_name] == nil or need_comm[func_name] == true) and (this.lowoperator == ''))then 
			that.value = "\\left( " .. that.value .. "\\right) "
		end

		that.lowoperator = oper_id
		if math_format_funcs[func_name] then
			that.value = mw.ustring.format(math_format_funcs[func_name], that.value)
		else
			that.value = (math_ext_funcs[func_name] or func_name) .. ' ' .. that.value
		end
		return that 
	end,
	apply_binary_operator = function(op1, op2, oper_id, oper_math,left_no,right_no)
		local left, right = p.tagmath.toTagMath(op1), p.tagmath.toTagMath(op2)
		if left.lowoperator ~= '(' and left.lowoperator ~= '' and
			((p.symbol_table[left.lowoperator] and p.symbol_table[left.lowoperator].ppriority and
			p.symbol_table[left.lowoperator].ppriority < p.symbol_table[oper_id].priority)) then
				if not left_no then
					left.value = "\\left( " .. left.value .. "\\right) " 
				end left.lowoperator = '('
		end
			
		if right.lowoperator ~= '(' and right.lowoperator ~= '' and 
			((p.symbol_table[right.lowoperator] and p.symbol_table[right.lowoperator].ppriority and
			p.symbol_table[right.lowoperator].ppriority < p.symbol_table[oper_id].priority)) then
				if not right_no then
					right.value = "\\left( " .. right.value .. "\\right) " 
				end right.lowoperator = '('
		end
			
		local low_operator = oper_id
		if ((p.symbol_table[left.lowoperator] or {ppriority=0}).ppriority or 0) ~= 0 then
			if p.symbol_table[left.lowoperator].ppriority < p.symbol_table[low_operator].ppriority then
				low_operator = left.lowoperator
			end
		end
		if ((p.symbol_table[right.lowoperator] or {ppriority=0}).ppriority or 0) ~= 0 then
			if p.symbol_table[right.lowoperator].ppriority < p.symbol_table[low_operator].ppriority then
				low_operator = right.lowoperator
			end
		end
		left.lowoperator = low_operator
		left.value = "{ {" .. left.value .. '}'  .. oper_math .. '{' .. right.value .. "} }"
		return left 
	end,
	TagMathMeta = {
		__add = function (op1, op2) 
			return p.tagmath.apply_binary_operator(op1,op2,'+','+')
		end,
		__sub = function (op1, op2) 
			return p.tagmath.apply_binary_operator(op1,op2,'-','-')
		end,
		__mul = function (op1, op2) 
			return p.tagmath.apply_binary_operator(op1,op2,'*',"\\times ")
		end,
		__div = function (op1, op2) 
			return p.tagmath.apply_binary_operator(op1,op2,'/',"\\div ")
		end,
		__tostring = function (this) return this.value end,
		__unm = function (this)
			local that, oper_id = p.tagmath.toTagMath(this), "- "
			if this.lowoperator ~= '(' and this.lowoperator ~= '' then that.value = "\\left( " .. that.value .. "\\right) "end
			that.lowoperator = oper_id
			that.value = "-{ " .. that.value .. "}"
			return that 
		end,
		__eq = function (op1, op2)return p.tagmath.tagMathString(op1).value == p.tagmath.tagMathString(op2).value end,
	},
	toTagMath = function(tagMathString)
		if type(tagMathString) == type({}) and tagMathString.numberType == "latex" then return tagMathString end
		if type(tagMathString) == type(nil) then return nil end
		local math_ext_const={["pi"]="\\pi",["π"]="\\pi",["°"]="{}^{\\circ}",["inf"]="\\infty",["nan"]="\\mathrm{NaN}",["nil"]="",["null"]=""}
		local TagMath = {}
		if (type(tagMathString) == type({})) and tagMathString.value ~= nil and tagMathString.lowoperator ~= nil then 
			TagMath = {value=tagMathString.value,lowoperator=tagMathString.lowoperator}
		else
			TagMath = {}
			TagMath.value = math_ext_const[tagMathString] or tagMathString
			TagMath.lowoperator = ''
		end
		setmetatable(TagMath,p.tagmath.TagMathMeta) 
		TagMath.numberType = "latex"
		return TagMath
	end,
	init = function()
		if comp_number == nil then comp_number = require("Module:Complex Number") end
		p.tagmath.zero = p.tagmath.toTagMath(0) 
		p.tagmath.one = p.tagmath.toTagMath(1) 
		p['nil'] = p.tagmath.toTagMath("")
		p.tagmath.noncalculate=true
		p.tagmath[0],p.tagmath[1] = p.tagmath.zero,p.tagmath.one
		new_meta = getmetatable( p.tagmath ) or {}
		new_meta.__index = function (this, func_name) 
			return function(...)return p.tagmath.apply_function(func_name, ...)end
		end
		setmetatable(p.tagmath,new_meta) 
		p.tagmath.numberType = comp_number._numberType
		p.tagmath.constructor = p.tagmath.toTagMath
		return p.tagmath
	end
}

return p