/* Scientific MATHS LIBRARY ( Filename = Maths.ahk ) by Avi Aryan v3.43 Thanks to hd0202, smorgasbord, Uberi and sinkfaze Special thanks to smorgasbord for the factorial function ------------------------------------------------------------------------------ DOCUMENTATION - http://avi-aryan.github.io/ahk/functions/smaths.html Math-Functions.ahk - https://github.com/avi-aryan/Avis-Autohotkey-Repo/blob/master/Functions/Math-Functions.ahk ############################################################################## FUNCTIONS ############################################################################## * NOTES ARE PROVIDED WITH EACH FUNCTION IN THE FORM OF COMMENTS. EXPLORE * SM_Solve(Expression, AHK=false) --- Solves a Mathematical expression. (with extreme capabilites) * SM_Add(number1, number2) --- +/- massive numbers . Supports Real Nos (Everything) * SM_Multiply(number1, number2) --- multiply two massive numbers . Supports everything * SM_Divide(Dividend, Divisor, length) --- Divide two massive numbers . Supports everything . length is number of decimals smartly rounded. * SM_Greater(number1, number2, trueforequal=false) --- compare two massive numbers * SM_Prefect(number) --- convert a number to most suitable form. like ( 002 to 2 ) and ( 000.5600 to 0.56 ) * SM_fact(number) --- factorial of a number . supports large numbers * SM_toExp(number, decimals) --- Converts a number to Scientific notation format * SM_FromExp(sci_num) --- Converts a scientific type formatted number to a real number * SM_Pow(number, power) --- power of a number . supports large numbers and powers * SM_Mod(Dividend, Divisor) --- Mod() . Supports large numbers * SM_Round(number, decimals) --- Round() . Large numbers * SM_Floor(number) --- Floor() . large numbers * SM_Ceil(number) --- Ceil() . large number * SM_e(N, auto=1) --- returns e to the power N . Recommend auto=1 for speed * SM_Number2base(N, base) --- Converts N to base 'base' * SM_Base2Number(H, base) --- Converts H in base 'base' to a real number * SM_UniquePmt(pattern, ID, Delimiter=",") ;gives the unique permutation possible . ################################################################################ READ ################################################################################ * Pass the numbers as strings in each of these functions. This is done to avoid number trimming due to Internal AHK Limit * For a collection of general Math functions, see < Math-functions.ahk > */ ;msgbox % SM_Solve("%sin(1.59)% e %log(1000)%") ;is equal to sin(1.59) e log(1000) = 999.816 ;msgbox % SM_Solve("4 + ( 2*( 3+(4-2)*round(2.5) ) ) + (5c2)**(4c3)") ;msgbox % "The gravity on earth is: " SM_Solve("(6.67e-11 * 5.978e24) / 6.378e6^2") ;msgbox % Sm_fact(40) ;<--try puttin one more zero here ;msgbox,% SM_Mod( SM_Pow(3,77), 79) ;msgbox,% SM_Round("124389438943894389430909430438098232323.427239238023823923984",4) ;msgbox,% SM_ToExp("328923823982398239283923.238239238923", 3) ;msgbox,% SM_Divide("43.034934034904334", "89.3467436743", 10) ;msgbox,% SM_UniquePmt("abcdefghijklmnopqrstuvwxyz0123456789",12367679898956098) ;msgbox,% SM_Mod("-22","-7") ;msgbox % SM_fromexp("6.45423e10") ;msgbox,% SM_Divide("48.45","19.45",2) ;msgbox,% SM_UniquePmt("avi,annat,koiaur,aurkoi") ;msgbox,% SM_Solve("(28*45) - (45*28)") ;msgbox,% SM_Add("1280232382372012010120325634", "-12803491201290121201212.98") ;MsgBox,% SM_Solve("23898239238923.2382398923 + 2378237238.238239 - (989939.9939 * 892398293823)") ;msgbox,% SM_ToExp("0.1004354545") ;var = sqrt(10!) - ( 2**5 + 5*8 ) ;msgbox,% SM_Solve(var) ;Msgbox,% SM_Greater(18.789, 187) ;msgbox,% SM_Divide("434343455677690909087534208967834434444.5656", "8989998989898909090909009909090909090908656454520", 100) ;MsgBox,% SM_Multiply("111111111111111111111111111111111111111111.111","55555555555555555555555555555555555555555555.555") ;MsgBox,% SM_Prefect("00.002000") ;msgbox % t:=SM_Number2Base("10485761048", 2) ;base 2 ;msgbox % f:=SM_Number2base("10485761048", 32) ;base 32 ;msgbox % SM_Base2Number(t, 2) "`n" SM_Base2Number(f, 32) ;return ;################################################################################################################################################################### ;#Include, Maths.ahk /* SM_Solve(expression, ahk=false) Solves the expression in string. SM_Solve() uses the powerful functions present in the library for processing ahk = true will make SM_Solve() use Ahk's +-/* for processing. Will be faster * You can use global variables in expressions . To make SM_Solve see them as global vars, surround them by %..% * To nest expressions with brackets , you can use the obvious ( ) brackets * You can use numbers in sci notation directly in this function . ("6.67e-11 * 4.23223e24") * You can use ! to calulate factorial ( 48! ) ( log(1000)! ) * You can use ^ or ** to calculate power ( 2.2321^12 ) ( 4**14 ) * You can use p or c for permutation or combination * Use %...% to use functions with e, c, p . ("4**sin(3.14) + 5c%log(100)% + %sin(1.59)%e%log(1000)% + log(1000)!") Example global someglobalvar := 26 msgbox,% SM_Solve("Sqrt(%someglobalvar%) * 4! * log(100) * ( 3.43e3 - 2^5 )") */ SM_Solve(expression, ahk=false){ static fchars := "e- e+ **- ** **+ ^- ^+ + - * / \" , rchars := "#< #> ^< ^> ^> ^< ^> ¢ ¤ ¥ ¦ ¦" ;Reject invalid if expression= return ;Check Expression for invalid if expression is alpha { temp2 := %expression% return %temp2% ;return value of expression if it is a global variable or nothing } else if expression is number { if !Instr(expression, "e") return expression } ;Fix Expression StringReplace,expression,expression,%A_space%,,All StringReplace,expression,expression,%A_tab%,,All expression := SM_Fixexpression(expression) ; Solving Brackets first while b_pos := RegexMatch(expression, "i)[\+\-\*\\\/\^]\(") { b_count := {"(": 1, ")": 0} b_temp := Substr(expression, b_pos+2) loop, parse, b_temp { b_count[A_LoopField] += 1 if b_count["("] = b_count[")"] { end_pos := A_index break } } expression := Substr(expression, 1, b_pos) SM_Solve( Substr(expression, b_pos+2, end_pos-1) ) Substr(expression, end_pos+b_pos+2) } ;Changing +,-,e-,e+ and all signs to different things expression := SM_FixExpression(expression) ;FIX again after solving brackets loop, { if !(Instr(expression, "(")){ expression := SM_PowerReplace(expression, fchars, rchars, "All") ;power replaces replaces those characters reserve .= expression break } temp := Substr(expression, 1, Instr(expression, "(")) ;till 4+2 + sin( temp := SM_PowerReplace(temp, fchars, rchars, "All") ;we dont want to replace +- inside functions temp2 := SubStr(expression, Instr(expression, "(") + 1, Instr(expression, ")") - Instr(expression, "(")) reserve .= temp . temp2 expression := Substr(expression,Instr(expression, ")")+ 1) } ; expression := reserve ; The final solving will be done now loop, parse, expression,¢¤¥¦ { ;Check for functions -- if RegExMatch(A_LoopField, "iU)^[a-z0-9_]+\(.*\)\$") ;Ungreedy ensures throwing cases like sin(45)^sin(95) { fname := Substr(A_LoopField, 1, Instr(A_loopfield,"(") - 1) ;extract func ffeed := Substr(A_loopfield, Instr(A_loopfield, "(") + 1, Instr(A_loopfield, ")") - Instr(A_loopfield, "(") - 1) ;extract func feed loop, parse, ffeed,`, { StringReplace,feed,A_loopfield,",,All feed%A_index% := SM_Solve(feed) totalfeeds := A_index } if fname = SM_toExp outExp := 1 ; now output will be in Exp , set feed1 as the number , number := feed1 else if totalfeeds = 1 number := %fname%(feed1) else if totalfeeds = 2 number := %fname%(feed1, feed2) else if totalfeeds = 3 number := %fname%(feed1, feed2, feed3) else if totalfeeds = 4 number := %fname%(feed1, feed2, feed3, feed4) ;Add more like this if needed function := 1 } else number := A_LoopField , function := 0 ;Perform the previous assignment routine if (char != "") { ;The order is important here if (!function) { while match_pos := RegExMatch(number, "iU)%.*%", output_var) output_var := Substr(output_var, 2 , -1) , number := Substr(number, 1, match_pos-1) SM_Solve(Instr(output_var, "(") ? output_var : %output_var%) Substr(number, match_pos+Strlen(output_var)+2) if Instr(number, "#") or Instr(number, "^") number := SM_PowerReplace(number, "#< #> ^> ^<", "e- e ^ ^-", "All") ;replace #,^ back to e and ^ ;Symbols ;As all use SM_Solve() , else-if is OK if ( p := Instr(number, "c") ) or ( p := p + Instr(number, "p") ) ;permutation or combination term_n := Substr(number, 1, p-1) , term_r := Substr(number,p+1) , number := SM_Solve( term_n "!/" term_r "!" ( Instr(number, "c") ? "/(" term_n "-" term_r ")!" : "" ) ) else if Instr(number, "^") number := SM_Pow( SM_Solve( SubStr(number, 1, posofpow := Instr(number, "^")-1 ) ) , SM_Solve( Substr(number, posofpow+2) ) ) else if Instr(number, "!") number := SM_fact( SM_Solve( Substr(number, 1, -1) ) ) else if Instr(number, "e") ; solve e number := SM_fromExp( number ) } if (Ahk){ if char = ¢ solved := solved + (number) else if char = ¤ solved := solved - (number) else if char = ¦ { if !number return solved := solved / (number) } else if char = ¥ solved := solved * (number) }else{ if char = ¢ solved := SM_Add(solved, number) else if char = ¤ solved := SM_Add(solved,"-" . number) else if char = ¦ { if !number return solved := SM_Divide(solved, number) } else if char = ¥ solved := SM_Multiply(solved, number) } } if solved = solved := number char := Substr(expression, Strlen(A_loopfield) + 1,1) expression := Substr(expression, Strlen(A_LoopField) + 2) ;Everything except number and char } return, outExp ? SM_ToExp( solved ) : SM_Prefect( solved ) } ;############################################################################################################################### /* SM_Add(number1, number2, prefect=true) Adds or subtracts 2 numbers To subtract A and B , do like SM_Add(A, "-" B) i.e. append a minus */ SM_Add(number1, number2, prefect=true){ ;Dont set Prefect false, Just forget about it. ;Processing IfInString,number2,-- count := 2 else IfInString,number2,- count := 1 else count := 0 IfInString,number1,- count+=1 ; n1 := number1 n2 := number2 StringReplace,number1,number1,-,,All StringReplace,number2,number2,-,,All ;Decimals dec1 := Instr(number1,".") ? StrLen(number1) - InStr(number1, ".") : 0 dec2 := Instr(number2,".") ? StrLen(number2) - InStr(number2, ".") : 0 if (dec1 > dec2){ dec := dec1 loop,% (dec1 - dec2) number2 .= "0" } else if (dec2 > dec1){ dec := dec2 loop,% (dec2 - dec1) number1 .= "0" } else dec := dec1 StringReplace,number1,number1,. StringReplace,number2,number2,. ;Processing ;Add zeros if (Strlen(number1) >= StrLen(number2)){ loop,% (Strlen(number1) - strlen(number2)) number2 := "0" . number2 } else loop,% (Strlen(number2) - strlen(number1)) number1 := "0" . number1 n := strlen(number1) ; if count not in 1,3 ;Add { loop, { digit := SubStr(number1,1 - A_Index, 1) + SubStr(number2, 1 - A_index, 1) + (carry ? 1 : 0) if (A_index == n){ sum := digit . sum break } if (digit > 9){ carry := true digit := SubStr(digit, 0, 1) } else carry := false sum := digit . sum } ;Giving sign if (Instr(n2,"-") and Instr(n1, "-")) sum := "-" . sum } ;SUBTRACT ****************** elsE { ;Compare numbers for suitable order numbercompare := SM_Greater(number1, number2, true) if !(numbercompare){ mid := number2 number2 := number1 number1 := mid } loop, { digit := SubStr(number1,1 - A_Index, 1) - SubStr(number2, 1 - A_index, 1) + (borrow ? -1 : 0) if (A_index == n){ StringReplace,digit,digit,- sum := digit . sum break } if Instr(digit, "-") borrow:= true , digit := 10 + digit ;4 - 6 , then 14 - 6 = 10 + (-2) = 8 else borrow := false sum := digit sum } ;End of loop ;Giving Sign ; If InStr(n2,"--"){ if (numbercompare) sum := "-" . sum }else If InStr(n2,"-"){ if !(numbercompare) sum := "-" . sum }else IfInString,n1,- if (numbercompare) sum := "-" . sum } ;End of Subtract - Sum ;End if ((sum == "-")) ;Ltrim(sum, "0") == "" sum := 0 ;Including Decimal If (dec) if (sum) sum := SubStr(sum,1,StrLen(sum) - dec) . "." . SubStr(sum,1 - dec) ;Prefect return, Prefect ? SM_Prefect(sum) : sum } ;################################################################################################################### /* SM_Multiply(number1, number2) Multiplies any two numbers */ SM_Multiply(number1, number2){ ;Getting Sign positive := true if Instr(number2, "-") positive := false if Instr(number1, "-") positive := !positive number1 := Substr(number1, Instr(number1, "-") ? 2 : 1) number2 := Substr(number2, Instr(number2, "-") ? 2 : 1) ; Removing Dot dec := InStr(number1,".") ? StrLen(number1) - InStr(number1, ".") : 0 If n2dotpos := Instr(number2, ".") dec := dec + StrLen(number2) - n2dotpos StringReplace,number1,number1,. StringReplace,number2,number2,. ; Multiplying loop,% Strlen(number2) number2temp .= Substr(number2, 1-A_Index, 1) number2 := number2temp ;Reversing for suitable order product := "0" Loop,parse,number2 { ;Getting Individual letters row := "0" zeros := "" if (A_loopfield) loop,% (A_loopfield) row := SM_Add(row, number1, 0) else loop,% (Strlen(number1) - 1) ;one zero is already 5 lines above row .= "0" loop,% (A_index - 1) ;add suitable zeroes to end zeros .= "0" row .= zeros product := SM_Add(product, row, false) } ;Give Dots if (dec){ product := SubStr(product,1,StrLen(product) - dec) . "." . SubStr(product,1 - dec) product := SM_Prefect(product) } ;Give sign if !(positive) product := "-" . product return, product } ;###################################################################################################################################### /* SM_Divide(number1, number2, length=10) Divide any two numbers length = defines the number of decimal places in the result */ SM_Divide(number1, number2, length=10){ ;Getting Sign positive := true if (Instr(number2, "-")) positive := false if (Instr(number1, "-")) positive := !positive StringReplace,number1,number1,- StringReplace,number2,number2,- ;Perfect them number1 := SM_Prefect(number1) , number2 := SM_Prefect(number2) ;Cases ;if !number1 && !number2 ; return 1 if !number2 ; return blank if denom is 0 return ;Remove Decimals dec := 0 if Instr(number1, ".") dec := - (Strlen(number1) - Instr(number1, ".")) ;-ve as when the num is multiplied by 10, 10 is divided if Instr(number2, ".") dec := Strlen(number2) - Instr(number2, ".") + dec + 0 StringReplace,number1,number1,. StringReplace,number2,number2,. number1 := Ltrim(number1, "0") , number2 := Ltrim(number2, "0") decimal := dec , num1 := number1 , num2 := number2 ;These wiil be used to handle point insertion n1 := Strlen(number1) , n2 := StrLen(number2) ;Stroring n1 & n2 as they will be used heavily below ;Widen number1 loop,% n2 + length number1 .= "0" coveredlength := 0 , dec := dec - n2 - length , takeone := false , n1f := n1 + n2 + length ;Start while(number1 != "") { times := 0 , below := "" , lendivide := 0 , n1fromleft := (takeone) ? Substr(number1, 1, n2+1) : Substr(number1, 1, n2) if SM_Greater(n1fromleft, number2, true) { todivide := n1fromleft loop, 10 { num2temp%A_index% := SM_Multiply(number2, A_index) if !(SM_Greater(todivide, num2temp%A_index%, true)){ lendivide := (takeone) ? n2 + 1 : n2 times := A_index - 1 , below := num2temp%times% break } } res .= zeroes_r } else { todivide := SubStr(number1, 1, n2+1) ; :-P (takeone) will not be needed here loop, 10 { num2temp%A_index% := SM_Multiply(number2, A_index) if !(SM_Greater(todivide, num2temp%A_index%, true)){ lendivide := n2 + 1 times := A_index - 1 , below := num2temp%times% break } } if (coveredlength != 0) res .= zeroes_r "0" } res .= times , coveredlength+=(lendivide - Strlen(remainder)) ;length of previous remainder will add to number1 and so is not counted remainder := SM_Add(todivide, "-" below) if remainder = 0 remainder := "" number1 := remainder . Substr(number1, lendivide + 1) if SM_Greater("0", remainder, true) { zeroes_k := "" loop,% Strlen(number1) zeroes_k .= "0" if (number1 == zeroes_k){ StringTrimRight,number1,number1,1 number1 := "1" . number1 res := SM_Multiply(res, number1) break } } if times = 0 break zeroes_r := "" , takeone := false if (remainder == "") { loop, if (Instr(number1, "0") == 1) zeroes_r .= "0" , number1 := Substr(number1, 2) , coveredlength+=1 else break } if (Strlen(remainder) == n2) takeone := true else loop,% n2 - StrLen(remainder) - 1 zeroes_r .= "0" } ;Putting Decimal points" if (dec < 0) { oldformat := A_formatfloat SetFormat,float,0.16e Divi := Substr(num1,1,15) / Substr(num2,1,15) ; answer in decimals decimal := decimal + Strlen(Substr(num1,16)) - Strlen(Substr(num2,16)) if (Instr(divi,"-")) decimal := decimal - Substr(divi,-1) + 1 else decimal := decimal + Substr(divi,-1) + 1 if (decimal > 0) res := Substr(res, 1, decimal) . "." . Substr(res, decimal + 1) else if (decimal < 0){ loop,% Abs(decimal) zeroes_e .= "0" res := "0." zeroes_e res } else res := "0." res SetFormat,float,%oldformat% } else { num := "1" loop,% dec num .= "0" res := SM_Multiply(SM_Prefect(res), num) } return, ( (positive) ? "" : "-" ) . SM_Round(SM_Prefect(res), decimal < 0 ? Abs(decimal)+length : length) } ;########################################################################################################################################## /* SM_UniquePmt(series, ID="", Delimiter=",") Powerful Permutation explorer function that uses an unique algorithm made by the author to give a unique sequence linked to a number. For example, the word "abc" has 6 permutations . So, SM_UniquePmt("abc", 1) gives a different sequence, ("abc", 2) a different till ("abc", 6) As the function is powered by the the specialist Mod, Division and Multiply functions, it can handle series larger series too. Examples -- msgbox,% SM_UniquePmt("abcd") ;leaving ID = "" gives all permutations msgbox,% SM_UniquePmt("abcdefghijklmnopqrstuvwxyz123456789", 23322323323) ;<----- That's called huge numbers */ SM_UniquePmt(series, ID="", Delimiter=","){ if Instr(series, Delimiter) loop, parse, series,%Delimiter% item%A_index% := A_LoopField , last := lastbk := A_Index else{ loop, parse, series item%A_index% := A_loopfield last := lastbk := Strlen(series) , Delimiter := "" } if (ID == "") ;Return all possible permutations { fact := SM_fact(last) loop,% fact toreturn .= SM_UniquePmt(series, A_index) . "`n" return, Rtrim(toreturn, "`n") } posfactor := (SM_Mod(ID, last) == "0") ? last : SM_Mod(ID, last) incfactor := (SM_Mod(ID, last) == "0") ? SM_Floor(SM_Divide(ID,last)) : SM_Floor(SM_Divide(ID,last)) + 1 loop,% last { tempmod := SM_Mod(posfactor + incfactor - 1, last) ;should be faster posfactor := (tempmod == "0") ? last : tempmod ;Extraction point res .= item%posfactor% . Delimiter , item%posfactor% := "" loop,% lastbk if (item%A_index% == "") plus1 := A_index + 1 , item%A_index% := item%plus1% , item%plus1% := "" last-=1 if (posfactor > last) posfactor := 1 } return, Rtrim(res, Delimiter) } ;#################################################################################################################################### /* SM_Greater(number1, number2, trueforqual=false) Evaluates to true if number1 > number2 If the "trueforequal" param is true , the function will also evaluate to true if number1 = number2 */ SM_Greater(number1, number2, trueforequal=false){ IfInString,number2,- IfNotInString,number1,- return, true IfInString,number1,- IfNotInString,number2,- return, false if (Instr(number1, "-") and Instr(number2, "-")) bothminus := true number1 := SM_Prefect(number1) , number2 := SM_Prefect(number2) ; Manage Decimals dec1 := (Instr(number1,".")) ? ( StrLen(number1) - InStr(number1, ".") ) : (0) dec2 := (Instr(number2,".")) ? ( StrLen(number2) - InStr(number2, ".") ) : (0) if (dec1 > dec2) loop,% (dec1 - dec2) number2 .= "0" else if (dec2 > dec1) loop,% (dec2 - dec1) number1 .= "0" StringReplace,number1,number1,. StringReplace,number2,number2,. ; Compare Lengths if (Strlen(number1) > Strlen(number2)) return,% (bothminus) ? (false) : (true) else if (Strlen(number2) > Strlen(number1)) return,% (bothminus) ? (true) : (false) else ;The final way out { stop := StrLen(number1) loop, { if (SubStr(number1,A_Index, 1) > Substr(number2,A_index, 1)) return bothminus ? 0 : 1 else if (Substr(number2,A_index, 1) > SubStr(number1,A_Index, 1)) return bothminus ? 1 : 0 if (a_index == stop) return, (trueforequal) ? 1 : 0 } } } ;######################################################################################################################################### /* SM_Prefect(number) Converts any number to Perfect form i.e removes extra zeroes and adds reqd. ones. eg > SM_Prefect(000343453.4354500000) */ SM_Prefect(number){ number .= "" ;convert to string if needed number := RTrim(number, "+-") if number= return 0 if Instr(number, "-") number := Substr(number, 2) , negative := true if Instr(number, "."){ number := Trim(number, "0") if (Substr(number,1,1) == ".") ;if num like .6767 number := "0" number if (Substr(number, 0) == ".") ;like 456. number := Substr(number, 1, -1) return,% (negative) ? ("-" . number) : (number) } ; Non-decimal below else { if Trim(number, "0") return negative ? ("-" . Ltrim(number, "0")) : (Ltrim(number, "0")) else return 0 } } ;########################################################################################################################################### /* SM_Mod(dividend, divisor) Gives remanider when dividend is divided by divisor */ SM_Mod(dividend, divisor){ ;Signs positive := true if Instr(divisor, "-") positive := false if (Instr(dividend, "-")) positive := !positive dividend := Substr(dividend, Instr(dividend, "-") ? 2 : 1) , divisor := Substr(divisor, Instr(divisor, "-") ? 2 : 1) , Remainder := dividend ;Calculate no of occurances if SM_Greater(dividend, divisor, true){ div := SM_Divide(dividend, divisor) div := Instr(div, ".") ? SubStr(div, 1, Instr(div, ".") - 1) : 0 if ( div == "0" ) Remainder := 0 else Remainder := SM_Add(dividend, "-" SM_Multiply(Divisor, div)) } return, ( (Positive or Remainder=0) ? "" : "-" ) . Remainder } ;############################################################################################################################################ /* SM_ToExp(number, decimals="") // SM_Exp Gives exponential form of representing a number. If decimals param is omitted , it is automatically detected. ? SM_Exp was the function's name in old versions and so a dummy function has been created */ SM_Exp(number, decimals=""){ return SM_ToExp(number, decimals) } SM_ToExp(number, decimals=""){ if (dec_pos := Instr(number, ".")) { number := SM_Prefect(number) , number := Substr(number, Instr(number, "0")=1 ? 2 : 1) Loop, parse, number { if A_loopfield > 0 break tempnum .= A_LoopField } number := Substr(number, Strlen(tempnum)+1) , power := dec_pos-Strlen(tempnum)-2 number2 := Substr(number, 2) StringReplace,number2,number2,. number := Substr(number, 1, 1) "." number2 decimals := ( decimals="" or decimals>Strlen(number2) ) ? Strlen(number2) : decimals return SM_Round(number, decimals) "e" power } else { number := SM_Prefect(number) , decimals := ( decimals="" or decimals>Strlen(Substr(number,2)) ) ? Strlen(Substr(number,2)) : decimals return SM_Round( Substr(number, 1, 1) "." Substr(number, 2), decimals ) "e" Strlen(number)-1 } } /* SM_FromExp(expnum) Converts exponential form to number */ SM_FromExp(expnum){ if !Instr(expnum, "e") return expnum n1 := Substr(expnum, 1, t := Instr(expnum, "e")-1) , n2 := Substr(expnum, t+2) return SM_ShiftDecimal(n1, n2) } ;####################################################################################################################################### /* SM_Round(number, decimals) Rounds a infinitely sized number to given number of decimals */ SM_Round(number, decimals){ if Instr(number,".") { nofdecimals := StrLen(number) - ( Instr(number, ".") = 0 ? Strlen(number) : Instr(number, ".") ) if (nofdecimals > decimals) { secdigit := Substr(number, Instr(number,".")+decimals+1, 1) if secdigit >= 5 loop,% decimals-1 zeroes .= "0" number := SM_Add(Substr(number, 1, Instr(number, ".")+decimals), (secdigit >= 5) ? "0." zeroes "1" : "0") } else { loop,% decimals - nofdecimals zeroes .= "0" number .= zeroes } return, Rtrim(number, ".") } else return, number } ;################################################################################################################################################### /* SM_Floor(number) Floor function with extended support. Refer to Ahk documentation for Floor() */ SM_Floor(number){ number := SM_Prefect(number) if Instr(number, "-") if Instr(number,".") return, SM_Add(Substr(number, 1, Instr(number, ".") - 1), -1) else return, number else return, Instr(number, ".") ? Substr(number, 1, Instr(number, ".") - 1) : number } ;################################################################################################################################################## /* SM_Ceil(number) Ceil function with extended support. Refer to Ahk documentation for Ceil() */ SM_Ceil(number){ number := SM_Prefect(number) if Instr(number, "-") { if Instr(number,".") return, Substr(number, 1, Instr(number, ".") - 1) else return, number } else return, Instr(number, ".") ? SM_Add( Substr(number, 1, Instr(number, ".") - 1), 1) : number } ;################################################################################################################################################# /* SM_fact(number) Gives factorial of number of any size. Try SM_fact(200) :-; ;--- Edit Now SM_Fact() uses smorgasboard method for faster results http://ahkscript.org/boards/viewtopic.php?f=22&t=176&p=4786#p4781 */ SM_fact(N){ res := 1 , k := 1 , carry := 0 N -= 1 loop % N { StringSplit, l_times, res index := l_times0 k := A_index + 1 Loop %index% { digit := k * l_times%index% + carry if ( digit > 9 ) { carry := RegExReplace(digit, "(.*)(\d)", "\$1") digit := RegExReplace(digit, "(.*)(\d)", "\$2") } else carry := 0 r := digit r index -- } if ( carry != 0 ) final := carry r else final := r res := final digit := index := final := r = r := "" carry := 0 } return final ? final : 1 } /* SM_Pow(number, power) Gives the power of a number . Uses SM_Multiply() for the purpose */ SM_Pow(number, power){ if (power < 1) { if !power ;0 return 1 if power Between -1 and 1 return number ** power power := -power , I := Floor(power) , D := Mod(power, 1) if Instr(number, "-") && D ;if number is - and power is - in decimals , it doesnt exist ... -4 ** -2.5 return D_part := number ** D ;The power of decimal part I_part := SM_Pow(number, I) ;Now I will always be >=1 . So it will fall in the below else part return SM_Prefect( SM_Divide(1, SM_Multiply(I_part, D_part)) ) } else { if power > 6 { sqrt_c := Floor(Sqrt(power)) x_c := SM_Iterate(number, sqrt_c) , loopc := Floor(power/sqrt_c) x_c_loop := SM_iterate(x_c, loopc) , remPow := power - (sqrt_c*loopc) x_remPow := SM_iterate(number, remPow) return SM_Multiply(x_c_loop, x_remPow) } else x_7_pow7 := 1 a := 1 loop % Mod(power, 7) a := SM_Multiply(number, a) return SM_Multiply(x_7_pow7, a) } } /* SM_e(N, auto=1) Gives the power of e to N auto = 1 enables smart rounding for faster results Call auto as false (0) for totally accurate results. (may be slow) */ SM_e(N, auto=1){ static e := 2.71828182845905 , d := 14 ;rendering precise results with speed . if (N > 5) and auto e := SM_Round("2.71828182845905", (F := d-N+5)>2 ? F : 2) return SM_Pow(e, N) } /* SM_ base Conversion functions via Base to Number and Number to Base conversion Base = 16 for HexaDecimal , 2 for Binary, 8 for Octal and 10 for our own number system */ SM_Number2Base(N, base=16){ baseLen:=base<10 ? SM_Ceil((10/base)*Strlen(N)) : Strlen(N) if SM_checkformat(N) && SM_Checkformat(base**(baseLen-1)) ;check if N and base**base (used below) is compatitible loop % baseLen D:=Floor(N/(T:=base**(baseLen-A_index))),H.=!D?0:(D>9?Chr(D+87):D),N:=N-D*T else loop % baseLen D:=SM_Floor( SM_Divide(N , T:= SM_Pow(base, baselen-A_index)) ) , H.=!D?0:(D>9?Chr(D+87):D) , N:=SM_Add( N, "-" SM_Multiply(D,T) ) return Ltrim(H,"0") } SM_Base2Number(H, base=16){ StringLower, H, H ;convert to lowercase for Asc to work S:=Strlen(H),N:=0 loop,parse,H N := SM_Add( N, SM_Multiply( (A_LoopField*1="")?Asc(A_LoopField)-87:A_LoopField , SM_Pow(base, S-A_index) ) ) return N } ;################# NON - MATH FUNCTIONS ####################################### ;################# RESERVED ################################################### ; Checks if n is within AHK range SM_Checkformat(n){ static ahk_ct := 9223372036854775807 if n < 0 return 0 if ( ahk_ct > n+0 ) return 1 } ;Shifts the decimal point ;specify - to shift in left direction SM_ShiftDecimal(number, dec_shift=0){ if Instr(number, "-") number := Substr(number,2) , minus := 1 dec_pos := Instr(number, ".") , numlen := StrLen(number) loop % Abs(dec_shift) ;create zeroes zeroes .= "0" if !dec_pos ;add decimal to integers number .= ".0" number := dec_shift>0 ? number zeroes : zeroes number ;append zeroes dec_pos := Instr(number, ".") ;get dec_pos in the new number StringReplace, number, number, % "." number := Substr(number, 1, dec_pos+dec_shift-1) "." Substr(number, dec_pos+dec_shift) return ( minus ? "-" : "" ) SM_Prefect(number) } ; powers a number n times SM_Iterate(number, times){ x := 1 loop % times x := SM_Multiply(x, number) return x } ; fast string replace SM_PowerReplace(input, find, replace, options="All"){ StringSplit, rep, replace, % A_space loop, parse, find, % A_Space StringReplace, input, input, % A_LoopField, % rep%A_index%, % options return Input } SM_FixExpression(expression){ expression := Rtrim(expression, "+-=*/\^") StringReplace,expression,expression,--,+,All StringReplace,expression,expression,-+,-,All StringReplace,expression,expression,+-,-,All StringReplace,expression,expression,++,+,All ;Reject invalid if expression= return ;if (Substr(expression, 1, 1) != "+") or (Substr(expression, 1, 1) != "-") if Substr(expression, 1, 1) == "-" expression := "0" expression ;make it 0 - 10 else expression := "+" expression loop, { if Instr(expression, "*-"){ fromleft := Substr(expression, 1, Instr(expression, "*-")) StringGetPos,posplus,fromleft,+,R StringGetPos,posminus,fromleft,-,R if (posplus > posminus) fromleft := Substr(fromleft, 1, posplus) "-" Substr(fromleft, posplus + 2) else fromleft := Substr(fromleft, 1, posminus) "+" Substr(fromleft, posminus + 2) expression := fromleft . Substr(expression, Instr(expression, "*-") + 2) }else if Instr(expression, "/-"){ fromleft := Substr(expression, 1, Instr(expression, "/-")) StringGetPos,posplus,fromleft,+,R StringGetPos,posminus,fromleft,-,R if (posplus > posminus) fromleft := Substr(fromleft, 1, posplus) "-" Substr(fromleft, posplus + 2) else fromleft := Substr(fromleft, 1, posminus) "+" Substr(fromleft, posminus + 2) expression := fromleft . Substr(expression, Instr(expression, "/-") + 2) }else if Instr(expression, "\-"){ fromleft := Substr(expression, 1, Instr(expression, "\-")) StringGetPos,posplus,fromleft,+,R StringGetPos,posminus,fromleft,-,R if (posplus > posminus) fromleft := Substr(fromleft, 1, posplus) "-" Substr(fromleft, posplus + 2) else fromleft := Substr(fromleft, 1, posminus) "+" Substr(fromleft, posminus + 2) expression := fromleft . Substr(expression, Instr(expression, "\-") + 2) }else if Instr(expression, "x-"){ fromleft := Substr(expression, 1, Instr(expression, "x-")) StringGetPos,posplus,fromleft,+,R StringGetPos,posminus,fromleft,-,R if (posplus > posminus) fromleft := Substr(fromleft, 1, posplus) "-" Substr(fromleft, posplus + 2) else fromleft := Substr(fromleft, 1, posminus) "+" Substr(fromleft, posminus + 2) expression := fromleft . Substr(expression, Instr(expression, "x-") + 2) }else break } StringReplace,expression,expression,--,+,All StringReplace,expression,expression,-+,-,All StringReplace,expression,expression,+-,-,All StringReplace,expression,expression,++,+,All return, expression } ;<------------------------------------------- BYE -------------------------------------------------------------------------------->