MathFunctions.js

'use strict'
/*--------------Statistics--------------*/
// Key: A = Array, i.e. [#,#,..]

const Minimum=A=>{let L=A.length,M=A[--L];while(--L>=0){const N=A[L];N<M&&(M=N)};return M}
,Maximum=A=>{let L=A.length,M=A[--L];while(--L>=0){const N=A[L];N>M&&(M=N)};return M}
,MinMax3N2=A=>{//This is a slightly faster algorithm to get both the Minimum and Maximum of an array at the same time
    let L=A.length,Min,Max
    if(L&1)//if odd
        Min=Max=A[--L]
    else{//if even
        const a=A[--L],b=A[--L];a>b?(Max=a,Min=b):(Max=b,Min=a)
    }
    for(let Big,Small;L>0;){
        const a=A[--L],b=A[--L]
        a>b?(Big=a,Small=b):(Big=b,Small=a)
        Big>Max&&(Max=Big);Small<Min&&(Min=Small)
    }
    return[Min,Max]
}
,Range=A=>{const a=MinMax3N2(A);return a[1]-a[0]} // Max-Min

,Sum=A=>{let L=A.length,S=0;do{S+=A[--L]}while(L>0);return S} /* Σ
  e.g. Sum([3,4,4,5,12]) ➜ 28 */

,MeanAverage=A=>{const L=A.length;let l=L,Σ=A[--l];while(--l>=0)Σ+=A[l];return Σ/L} /* µ
   e.g. MeanAverage([3,4,5,12]) ➜ 6 , MeanAverage([3,4,4,5,12]) ➜ 5.6 */

,MedianAverage=A=>{A.sort((a,b)=>a-b);const L2=A.length/2;return L2%1?A[L2-0.5]:(A[L2]+A[L2-1])/2}
// e.g. MedianAverage([3,4,5,12]) ➜ 4.5 , MedianAverage([3,4,4,5,12]) ➜ 4

,Unique=A=>[...new Set(A)] /* e.g. Unique([3,4,'4',5,4,12]) ➜ [3,4,'4',5,12]
    Alternatively: Unique=A=>Array.from(new Set(A)) OR Unique=A=>A.filter((e,i,s)=>s.indexOf(e)==i) */
,CountOccurances=A=>{const C={};for(let L=A.length;--L>=0;){const E=A[L];C[E]?C[E]+=1:C[E]=1}return C}
// e.g. CountOccurances([3,4,4,5,12]) ➜ {'3':1,'4':2,'5':1,'12':1}

,ModeAverage=A=>{//Array items with higest occurances, not just numbers but also strings
    Array.isArray(A)&&(A=CountOccurances(A))//Input can be array [] or object {}
    const HighestOccurance=Maximum(Object.values(A))
    ,keys=Object.keys(A)
    let Mode=filteredKeys=keys.filter(key=>A[key]==HighestOccurance)

    Mode.length<2&&(Mode=Mode[0])/* if there's no tie for the highest occurance, 
    return only that value, otherwise return an array of the tied values */
    // May Do: convert each tied mode value to number if numeric & console.log 'tie' to inform

    console.log('Mode: ',Mode,', Occurance: '+HighestOccurance)
    return[Mode,HighestOccurance]
}// e.g. ModeAverage([3,4,4,5,12]) ➜ 'Mode:  4 , Occurance: 2' , [ '4', 2 ]

,Product=A=>{// ∏
    let L=A.length,P=A[--L];if(P==0)return 0
    while(--L>=0){const a=A[L];if(a==0)return 0;P*=a}
    return P
}// e.g. Product([1,3,4,7]) ➜ 84 , 1*3*4*7

// Efficiently returns 0 as soon as any is detected. This can also be modified to detect Infinity, -Infinity and NaN

,SumProduct=(A1,A2)=>{
    let L=A1.length,R=A1[--L]*A2[L]
    while(--L>=0)R+=A1[L]*A2[L]
    return R
}/* e.g. SumProduct([1,3],[4,7]) ➜ 25 , 1*4+3*7
    Weight Sum Model (WSM) in Multi-Criteria Analysis (MCA)
*/
,SumPower=(A1,A2)=>{
    let L=A1.length,R=A1[--L]**A2[L]
    while(--L>=0)R+=A1[L]**A2[L]
    return R
}// e.g. SumPower([1,3],[4,7]) ➜ 2188 , 1**4+3**7

,ProductPower=(A1,A2)=>{
    let L=A1.length,R=A1[--L]**A2[L];if(R==0)return 0
    while(--L>=0){const a=A1[L];if(a==0)return 0;R*=a**A2[L]}
    return R
}/* e.g. ProductPower([1,3],[4,7]) ➜ 2187 , 1**4*3**7
    Weight Product Model (WPM) in Multi-Criteria Analysis (MCA)
*/

,AscendingSort=A=>A.sort((a,b)=>a<b?-1:1) /* Both Numbers and Strings Alphabetically Ascendingly
    e.g. AscendingSort([-7.6,0,0.5,1,4.3,true,false,NaN,'str',' ',[],{},Infinity,-Infinity]) =>
        [-Infinity,-7.6,0,false,[],' ',0.5,1,true,4.3,NaN,{},'str',Infinity] */
,SortNumbers=A=>A.sort((a,b)=>a-b) /* Only numbers, but slightly more efficent. From smallest to biggest
    e.g. SortNumbers([0,-1.4,7.6]) ➜ [-1.4,0,7.6] */

,Rank=A=>{const S=A.slice().sort((a,b)=>a>b?-1:1);return A.map(v=>S.indexOf(v)+1)}
// rank values with biggest being #1 , e.g. Rank([0,-1.4,7.6]) ➜ [2,3,1] , Rank(['a','c','b']) ➜ [3,1,2]

,FractionRank=A=>{// Adds 0.5*(occurrences-1) per each tied rank
    const R=Rank(A),L=R.length,C=new Map()
    for(let i=-1;++i<L;){const r=R[i];C.has(r)||C.set(r,0);C.set(r,C.get(r)+1)}
    for(let i=-1;++i<L;)R[i]+=(C.get(R[i])-1)/2
    return R
}//e.g. FractionRank([5,62,5,0,4,-3.4,5,62]) ➜ [4, 1.5, 4, 7, 6, 8, 4, 1.5]

,SpearmanCorrelation=(A1,A2)=>{// Coefficient 'ρ': 1 ≥ ρ ≥ -1
    const n=A1.length,Rank1=FractionRank(A1),Rank2=FractionRank(A2);let Σd2=0
    for(let L=n;--L>=0;)Σd2+=(Rank1[L]-Rank2[L])**2
    return Number((1-(6*Σd2/(n*(n**2-1)))).toFixed(3)) // ρ = 1 - 6Σd²/n(n²-1)
}// e.g. SpearmanCorrelation([1,6,4,3,4],[9,5,9,7,2]) ➜ -0.475

,PearsonCorrelation=(A1,A2)=>{// Coefficient 'r': 1 ≥ r ≥ -1
    const n=A1.length
    if(n<2)return -Infinity // to prevent error in the console when used in some apps that may not accept NaN
    let i=n,S1=A1[--i],S2=A2[i],SP11=S1**2,SP22=S2**2,SP12=S1*S2 // 'S' is Sum and 'SP' is SumProduct
    while(--i>=0){
        const a1=A1[i],a2=A2[i]
        S1+=a1;S2+=a2;SP11+=a1**2;SP22+=a2**2;SP12+=a1*a2
    }
    return(n*SP12-S1*S2)/Math.sqrt((n*SP11-S1**2)*(n*SP22-S2**2))
    // r = (n∙Σ(x∙y)-Σ(x)∙Σ(y))/√((n∙Σ(x²)-(Σx)²)∙(n∙Σ(y²)-(Σy)²))
}// e.g. PearsonCorrelation([1,6,3,4],[9,5,7,2]) ➜ -0.520

//Population Covariance, Variance σ² & Standard Deviation σ
,COVAR_P=(A1,A2)=>{
    const L=A1.length;let i=L,µ1=A1[--i],µ2=A2[i]
    while(--i>=0){µ1+=A1[i];µ2+=A2[i]}µ1/=L;µ2/=L
    i=L;let C=(A1[--i]-µ1)*(A2[i]-µ2)
    while(--i>=0)C+=(A1[i]-µ1)*(A2[i]-µ2)
    return Number((C/L).toFixed(3))
}
,VAR_P=A=>{
    const L=A.length
    let i=L,µ=A[--i];while(--i>=0)µ+=A[i];µ/=L
    i=L;let V=(A[--i]-µ)**2;while(--i>=0)V+=(A[i]-µ)**2
    return Number((V/L).toFixed(3))
}/* e.g. VAR_P([85,92,64,99,56]) ➜ 271.76
    source: https://study.com/skill/learn/calculating-population-standard-deviation-explanation.html */
,STDEV_P=A=>Number(Math.sqrt(VAR_P(A)).toFixed(3))// e.g. STDEV_P([85,92,64,99,56]) ➜ 16.485

//Sample Covariance, Variance S² & Standard Deviation S
,COVAR_S=(A1,A2)=>{
    const L=A1.length;let i=L,µ1=A1[--i],µ2=A2[i]
    while(--i>=0){µ1+=A1[i];µ2+=A2[i]}µ1/=L;µ2/=L
    i=L;let C=(A1[--i]-µ1)*(A2[i]-µ2)
    while(--i>=0)C+=(A1[i]-µ1)*(A2[i]-µ2)
    return Number((C/(L-1)).toFixed(3))
}
,VAR_S=A=>{
    const L=A.length
    let i=L,µ=A[--i];while(--i>=0)µ+=A[i];µ/=L
    i=L;let V=(A[--i]-µ)**2;while(--i>=0)V+=(A[i]-µ)**2
    return Number((V/(L-1)).toFixed(3))
}// e.g. VAR_S([9,2,5,4,12,7]) ➜ 13.1 , source: https://www.ztable.net/sample-population-standard-deviation
,STDEV_S=A=>Number(Math.sqrt(VAR_S(A)).toFixed(3))// e.g. STDEV_S([9,2,5,4,12,7]) ➜ 3.619

/* Use Sample S equations of you only analyse a subset of a larger population, and Population σ equations if you analyse the entire population.
Variance returns the same result as entiring the same array as the 2 inputs for Covariance */

,FindIndices=(SearchedElement,A)=>{
    const Indices=[],L=A.length;let i=-1;do{A[i]==SearchedElement&&Indices.push(i)}while(++i<L);return Indices
} // e.g. FindIndices('h',[true,'h',6,'try',6,false,'h',0,-5.4,'h']) ➜ [1, 6, 9]

/*--------------Multi-Criteria Analysis (MCA)--------------*/

,NormaliseWeights=Weights=>{
    // This function inputs an array of numbers and divides each by their total, so the returned array will have a sum of 1.00

    let L=l=Weights.length,S=0;do{S+=Weights[--L]}while(L>0)
    while(--l>=0)Weights[l]/=S
    return Weights
}// e.g. NormaliseWeights([3,3,1,1,1,1,2]) ➜ [0.25,0.25,0.083,0.083,0.083,0.083,0.166]
,NormaliseScores=(Scores,Best,Worst)=>{
    // For a given single criterion 'Scores' is an array where each value corresponds to an alternative

    /*----------------------Checks----------------------*/ 
    if(isNaN(Best))return'Best Score Must Be A Number!'
    if(isNaN(Worst))return'Worst Score Must Be A Number!'
    if(Best==Worst)return'Best And Worst Scores Must Be Different Numbers!'

    /*----------------------Calculations----------------------*/ 
    for(let L=Scores.length;--L>=0;){
        const Score=(Scores[L]-Worst)/(Best-Worst) // Normalise the score between 1 and 0

        Scores[L]=Score<=0?0:Score>1?1:Score-0/* 
            if a score is out of bounds, make it equal to its nearest bound, i.e. 1 OR 0 
            '<=0' is used to avoid a score of '-0'
            'Score-0' is to return NaN instead of scripting isNaN(Score) to minify 
        */
    }
    return Scores
}// e.g. NormaliseScores([3,7,8,2,5,6,'String'],7,3) ➜ [0,1,1,0,0.5,0.75,NaN]

,PROMETHEE=(W,S,II)=>{
    // II: if(II==true){PROMETHEE II}else{PROMETHEE I}; W = Array of weights, S = Matrix of normalised scores between 0 and 1, with 0 being worst and 1 being best. # Rows = # Alternatives , # Cols = # Criteria Weights.

    /*----------------------Checks----------------------*/ 
    if(!W.every(s=>s>=0))return'Every weight needs to be either a positive number or 0'
    if(!S.flat(Infinity).every(s=>s<=1&&s>=0))
        return'Every score needs to be pre-normalised between 0 and 1. Please consider using the NormaliseScores function.'
    const C=W.length // C = # Criteria
    if(S[0].length!=C)return'#Criteria must equal the #Weights'

    /*----------------------Preparations----------------------*/ 
    const A=S.length // A = # Alternatives
    ,F=Array.from({length:3},()=>Array(A).fill(0)) // F has 3 cols for flows: Leaving, Entering And Net Total
    II=II==true?A-1:1

    /*----------------------Calculations----------------------*/
    for(let Am=A;--Am>=0;)// Am = Minuend Alternative
        for(let As=A;--As>=0;)// As = Subtrahend Alternative
            if(Am!=As)
                for(let c=C;--c>=0;){// c = Column
                    const Flow=Math.max(0,W[c]*(S[Am][c]-S[As][c]))/II
                    F[0][Am]+=Flow;F[1][As]+=Flow;F[2][Am]+=Flow;F[2][As]-=Flow
                }
    F[3]=Rank(F[2]) // last col is ranks with #1 being the best
    return F // returns a matrix of 4 columns with # Rows = # Alternatives
}
// e.g. PROMETHEE([0.38,0.09,0.05,0.22,0.17,0.08,0.02],[[0,0,0,0,0,1,0],[0.5,0.5,1/3,0,2/3,0.14286,0],[0.5,1,1,0.5,2/3,0.71429,1/3],[1,1,1,1,1,0,1],[0.5,0.5,1,0.5,2/3,1,1],[0,0,1/3,0,2/3,0.42857,0]],true) - https://www.econstor.eu/bitstream/10419/237008/1/1752580664.pdf

/*--------------Generate 1D Arrays--------------*/
/*
To generate an array of number 
The functions below are inspired by Casio calculators:
*/

,GenerateArraySSE=(Start,Step,End)=>{
    const A=[]
    do{A.push(Start);Start+=Step}while(Start<=End)
    return A
}// e.g. GenerateArraySSE(1,1.5,9) ➜ [1,2.5 4,5.5,7,8.5]

,GenerateArraySLS=(Start,Length,Step)=>{
    const A=[Start]
    for(let i=0;++i<Length;A[i]=Start)Start+=Step
    return A
}// e.g. GenerateArraySLS(0,10,1) ➜ [0,1,2,3,4,5,6,7,8,9]

,GenerateArrayLSE=(Length,Step,End)=>{
    const A=[]
    while(--Length>=0){A[Length]=End;End-=Step}
    return A
}// e.g. GenerateArrayLSE(8,2,30) ➜ [16,18,20,22,24,26,28,30]

/*--------------1D Arrays & 2D Matrices--------------*/

,ArrayFuncForEachElement=(F,A)=>A.map(x=>F(x)) // apply function F for each element x in array A
,MatrixFuncForEachElement=(F,M)=>M.map(r=>r.map(x=>F(x))) // apply function F for each element x in matrix M

,ArrayAddToEachElement=(A,n)=>A.map(e=>n+e) //e.g. ArrayAddToEachElement([-4,0,5.5],3) ➜ [-1,3,8.5]
,MatrixAddToEachElement=(M,n)=>M.map(r=>r.map(e=>e+=n)) //e.g. ArrayAddToEachElement([[-4,0],[5.5,-2.1]],3) ➜ [-1,3,8.5]

,ArraySubtractFromEachElement=(A,n)=>A.map(e=>e-n) //e.g. ArraySubtractFromEachElement([-4,0,5.5,-2.1],3) ➜ [-7,-3,2.5,-5.1]
,MatrixSubtractFromEachElement=(M,n)=>M.map(r=>r.map(e=>e-n)) //e.g. MatrixSubtractFromEachElement([[-4,0],[5.5,-2.1]],3) ➜ [[-7,-3],[2.5,-5.1]]

,ArrayMultiplyToEachElement=(A,n)=>A.map(e=>e*n) //e.g. ArrayMultiplyToEachElement([-4,0,5.5,-2.1],3) ➜ [-12,0,16.5,-6.3]
,MatrixMultiplyToEachElement=(M,n)=>M.map(r=>r.map(e=>e*n)) //e.g. MatrixMultiplyToEachElement([[-4,0],[5.5,-2.1]],3) ➜ [[-12,0],[16.5,-6.3]]

// I can add more of these 👆 but I think you get the general way of making these 😉
// Remember: you can turn any matrix into an array using A.flat() or A.flat(Infinity)

/*--------------2D Matrices--------------*/

,AddMatrices=(M1,M2)=>M1.map((R,r)=>R.map((e,c)=>e+=M2[r][c])) // M1 + M2
,SubtractMatrices=(M1,M2)=>M1.map((R,r)=>R.map((e,c)=>e-=M2[r][c])) // M1 - M2
,DotProductMatrices=(M1,M2)=>{// M1 ⋅ M2 | Matrix Multiplication
    const M2Rows=M2.length,M1Cols=M1[0].length
    if(M1Cols==undefined)//For 1D Arrays SumProduct, correct user input format
        M1=[M1]
    else if(M1[0].length!=M2Rows)
        return'#Cols of 1st Matrix must equal to #rows of 2nd matrix!'

    const Rows=M1.length,Cols=M2[0].length
    ,M=Array.from({length:Rows},()=>Array.from({length:Cols},()=>0))
    // When 2 matrices are multiplied, the resulting matrix has the same # rows as the 1st matrix and the same # cols as 2nd matrix

    // Row x Col → Row , Remember: fiRst seCond thiRd | R.C.R.
    for(let R=-1;++R<Rows;){
        for(let C=-1;++C<Cols;){
            for(let i=-1;++i<M2Rows;){
                M[R][C]+=M1[R][i]*M2[i][C]
            }
        }
    }
    return M
}

,RowElements=(M,r)=>M[r]
,ColElements=(M,c)=>M.map(R=>R[c])
,DiagonalElements=M=>M.map((R,C)=>R[C])

,Determinant2X2=M=>M[0][0]*M[1][1]-M[0][1]*M[1][0] // Only works on Matrix [[a,b],[c,d]] such that det(M)=|M|=a*d-b*c
,Determinant3X3=M=>M[0][0]*(M[1][1]*M[2][2]-M[1][2]*M[2][1])-M[0][1]*(M[1][0]*M[2][2]-M[1][2]*M[2][0])+M[0][2]*(M[1][0]*M[2][1]-M[1][1]*M[2][0])

,Excluding=i=>xs=>[...xs.slice(0,i),...xs.slice(i+1)]
,RecursiveDeterminant=([xs,...xss])=>xs.length==1?xs[0]:Sum(xs.map((x,i)=>(-1)**i*x*RecursiveDeterminant(xss.map(Excluding(i)))))

,Transpose=M=>M[0].length==1?M.flat():!isNaN(M[0])?M.map(x=>[x]):M[0].map((x,i)=>M.map(x=>x[i]))
// Don't confuse Transpose with Inverse

,IdentityMatrix=i=>Array.from({length:i},(x,r)=>Array.from({length:i},(y,c)=>(r==c?1:0)))

,MinorSubMatrix=(M,Row,Col)=>{// Deletes a row & a col
    if(!Number.isInteger(Row)||!Number.isInteger(Col))return'Please enter Row & Col as integers'
    if(M.length==2)return M[Math.abs(Row-1)][Math.abs(Col-1)]
    M.splice(Row,1);M.forEach(row=>row.splice(Col,1));return M
}

/*
Only Square (#Rows=#Cols) Matrices with non-zero determinant have an inverse matrix. This is because M⁻¹ = 1/det(M) ⋅ C, where C is the cofactor matrix, and only square matrices have determinants, if the determinant is zero, it would cause a division by zero as the determinant is a donominator.

An inverse of a matrix is defined as: M ⋅ M⁻¹ =  M⁻¹ ⋅ M = I , where I is an identity matrix of the same length.
Consequently, and as an aside, the inverse of the inverse matrix is equal to the original matrix: (M⁻¹)⁻¹ = M
*/

/*--------------Graphing 📈--------------*/
,TrapeziumRule=(x,Y)=>Number(((2*Sum(Y)-Y[0]-Y.at(-1))*x/2).toFixed(3)) // x = x-interval , Y = y-values Array

,LinearPolation=(x,x0,x1,y0,y1)=>{
    x>x0&&x>x1||x<x0&&x<x1?console.log('Extrapolation'):console.log('Interpolation')
    return Number((y0+(x-x0)*(y1-y0)/(x1-x0)).toFixed(3))// Outputs y
}// e.g. LinearPolation(5,1,8,3,8) ➜ Interpolation,5.857 , LinearPolation(-5,1,8,-3,8) ➜ Extrapolation,-12.429

,BestFitLine2Points=(x1,x2,y1,y2)=>{// Outputs [m,c] (m = gradient slope & c = y-intercep, of y = m⋅x + c)
    const m=Number(((y2-y1)/(x2-x1)).toFixed(3))
    return[m,Number((y1-m*x1).toFixed(3))] // alternatively (y2-m*x2)
}/* e.g. BestFitLine2Points(2,6,3,5) ➜ [0.5,2] , i.e. y = x/2 + 2
Other useful linear:
    m = (y - c) / x , for a specific single (x,y) coordinate with known c
    c = y - m⋅x , for a specific single (x,y) coordinate with known gradient
    x-intercep = -c/m , once both m and c are known
    e.g. -2/0.5 ➜ -4 
*/
,BestFitLineLSM=(X,Y)=>{//Least Square Method: inputs are arrays of x & y coordinates which must be of equal lengths
    let L=X.length,µ_Y=µ_X=N=D=0
    if(L!=Y.length)return'Please enter arrays of x and y coordinates of equal lengths'

    for(let i=L;--i>=0;µ_Y+=Y[i])µ_X+=X[i]
    µ_Y/=L;µ_X/=L

    while(--L>=0){const x=X[L]-µ_X;N+=x*(Y[L]-µ_Y);D+=x**2}
    const m=Number((N/D).toFixed(3))
    return[m,Number((µ_Y-m*µ_X).toFixed(3))]
}// Outputs [m,c] (m = gradient slope & c = y-intercep, of y = m⋅x + c)

/*--------------Iterative Greatest Common Divisor & Least Common Multiple--------------*/
/*
    a & b are single numbers, use gcd and lcm when only dealing with 2 numbers
    A is an array of numbers, use GCD and LCM when dealing with 3 or more numbers
*/
,gcd=(a,b)=>{let c;if(a<b){c=a;a=b;b=c};while(b!=0){c=a;a=b;b=c%b};return a} // e.g. gcd(24,32) ➜ 8
,GCD=A=>{let L=A.length,R=A[--L];while(--L>=0)R=gcd(R,A[L]);return R} // e.g. GCD([16,40,64]) ➜ 8
,lcm=(a,b)=>a*b/gcd(a,b) // e.g. lcm(6,9) ➜ 18
,LCM=A=>{let L=A.length,R=A[--L];while(--L>=0)R=lcm(R,A[L]);return R} // e.g. LCM([6,9,12]) ➜ 36

/*--------------Iterative Factorial ! Fractions & Negatives--------------*/
,Gamma=n=>{//The use of this 'Gamma' is to ensure Factorial can work on fractions, not just integers
    // g represents the precision desired, p is the values of p[i] to plug into Lanczos' formula
    //some magic constants
    const g=9,p=[0.99999999999980993,676.5203681218851,-1259.1392167224028,771.32342877765313,-176.61502916214059,12.507343278686905, -0.13857109526572012,9.9843695780195716e-6,1.5056327351493116e-7]
    if(n<0.5)return Math.PI/Math.sin(n*Math.PI)/Gamma(1-n)
    else{
        --n;let x=p[0]
        for(let i=0;++i<g;)x+=p[i]/(n+i)
        const t=n+g-1.5
        return Math.sqrt(2*Math.PI)*Math.pow(t,(n+0.5))*Math.exp(-t)*x
    }
}
,Factorial=n=>{
    if(n==0)return 1
    else if(Number.isInteger(n)){
        if(n>0){//positive integers
            let r=n;while(--n>1)r*=n;return r
        }else//negative integers
            return Infinity
    }else//fraction
        return Gamma(n+1)

/*--------------Iterative Fibonacci & Golden Ratio φ--------------*/
,Fib=I=>{//Fibonacci , I = Integer > -1
    if(I==0)return 0;if(I==1)return 1
    if(!Number.isInteger(I)||I<0)return'Please Enter A Positive Integer!'
    let a=0,b=i=1,f;while(++i<=I){f=a+b;a=b;b=f}
    return f
}// e.g. Fib(7) ➜ 13 , Fib(8) ➜ 21 , Fib(9) ➜ 34

,φ=(1+5**0.5)/2 /* Golden Ratio 1.618033988749895..
    Can be derived as a ratio of Fib(I+1)/Fib(I) where I is a large integer
    e.g. Fib(41)/Fib(40) ➜ 1.618033988749895
    I found by trial & error that I = 40 is the smallest integer to yield this accuracy
*/

/*--------------2 Vectors--------------*/
,AngleBetween2Vectors=(A,B)=>{
    let L=A.length,α=A[0],β=B[0],a=α**2,b=β**2,ab=α*β
    if(L!=B.length)return'Please enter A and B arrays of equal lengths'
    while(--L>0){α=A[L];β=B[L];a+=α**2;b+=β**2;ab+=α*β}
    const θ=Math.acos(ab/Math.sqrt(a)/Math.sqrt(b))
    if(θ==0||isNaN(θ))
        console.log('Parallel')
    else if(θ==Math.PI/2)
        console.log('Perpendicular')
    else
        console.log('Not Parallel Or Perpendicular')
    return θ
    // π/2 Radians ≥ Angle ≥ 0
}
,VectorsCrossProduct3D=(A,B)=>[A[1]*B[2]-A[2]*B[1],A[2]*B[0]-A[0]*B[2],A[0]*B[1]-A[1]*B[0]]
// Inputs [A0,A1,A2] & [B0,B1,B2] and returns 3X3 determinant of [[i,j,k],[A0,A1,A2],[B0,B1,B2]] in [i,j,k] format

/*--------------Randomness--------------*/
,Shuffle=A=>A.sort(()=>Math.random()-0.5) // Change the order of elements randomly like a deck of cards 🃏🎴

/*--------------Imaginary & Complex Numbers--------------*/
,ComplexSQRT=(a,b)=>{// Square Root √(a+bi), for real a & b
    if(b==undefined) // if no b is entered
        return Math.sqrt(a)
    // else if a non-zero b number is entered
        const HYPOT_ab=Math.hypot(a,b)
        return[Math.sqrt((HYPOT_ab+a)/2),Math.sign(b)*Math.sqrt((HYPOT_ab-a)/2)]
        //±[,][0] is real, ±[,][1] is imaginary
}
,ComplexCBRT=(a,b)=>{// Cube Root ₃√(a+bi), for real a & b
    if(b==undefined) // if no b is entered
        return Math.cbrt(a)
    // else if a non-zero b number is entered
        const θ=Math.atan2(b,a)/3,r=Math.cbrt(Math.hypot(a,b))
        return[r*Math.cos(θ),r*Math.sin(θ)] //[,][0] is real, [,][1] is imaginary
}

/*---Polynomials: General Solutions To Find Roots, Stationary Points & Their Natures---*/
//These find all the real and complex roots for x @ y=0 and stationary points and their natures for real/non-complex coefficients a, b, c, d, e & f

,SolveLinear=(m,c)=>//y=mx+c , m = gradient, c = y-intercep
    m==0?console.log('No Gradient? No Root!'):console.log('Root (y=0): x = '+Number((-c/m).toFixed(3)))

,SolveQuadratic=(a,b,c)=>{//y=ax²+bx+c, also known as parabolic
    if(a==0)//Must use SolveLinear(b,c) @ a=0, otherwise you'd divide by 0
        return SolveLinear(b,c)
    else{//https://en.wikipedia.org/wiki/Discriminant#Degree_2
        const Discriminant=b**2-4*a*c,a2=2*a,aNegative=a<0,x=Number((-b/a2).toFixed(3))// δy/δx = 0 = 2ax+b ∴ x=-b/(2a)
        ,Nature=aNegative?'Maxima':'Minima' // δ²y/δx² = 2a
        if(Discriminant==0)// 1 'repeated' real root which is also the stationary point
            console.log('Root (y=0) & '+Nature+': x = '+x)
        else{//Either 2 real roots OR 2 complex roots
            const sqrt_discriminantOver_2a=Number((Math.sqrt(Math.abs(Discriminant))/a2).toFixed(3))
            ,y=Number((a*x**2+b*x+c).toFixed(3))
            if(Discriminant>0){//2 real roots
                let x0=Number((x-sqrt_discriminantOver_2a).toFixed(3)),x1=Number((x+sqrt_discriminantOver_2a).toFixed(3))
                aNegative&&([x0,x1]=[x1,x0]) //sort so x₀<x₁
                console.log('• Roots (y=0): x₀ = '+x0+' , x₁ = '+x1+'\n• '+Nature+': x = '+x+' , y = '+y)
            }else{//2 complex roots
                let Roots=x+' ± '+Math.abs(sqrt_discriminantOver_2a)+' i';Math.abs(sqrt_discriminantOver_2a)==1&&(Roots=x+' ± i')
                console.log('• Roots (y=0): x = '+Roots+'\n• '+Nature+': x = '+x+' , y = '+y)
            }
        }
    }
}
,QuadraticDiscriminant=(a,b,c)=>{//y=ax²+bx+c, also known as parabolic
    if(a==0)
        return SolveLinear(b,c)
    else{//https://en.wikipedia.org/wiki/Discriminant#Degree_2
        const Discriminant=b**2-4*a*c
        if(Discriminant==0)
            console.log("• 1 'repeated' real root which is also the stationary point")
        else if(Discriminant>0)
            console.log('• 2 real roots')
        else//Discriminant<0
            console.log('• 2 complex roots')
        return Discriminant
    }
}
,CubicDiscriminant=(a,b,c,d)=>{//y=ax³+bx²+cx+d
    if(a==0)
        return SolveQuadratic(b,c,d)
    else{//https://en.wikipedia.org/wiki/Discriminant#Degree_3
        const Discriminant=18*a*b*c*d-4*d*b**3+b**2*c**2-4*a*c**3-27*a**2*d**2
        if(Discriminant==0)
            console.log('• At least 1 stationary point is also a root')
        else if(Discriminant>0)//∴ Quadratic_Discriminant 4*(b**2-3*a*c)>0
            console.log('• 3 real distinct roots')
        else//Discriminant<0
            console.log("• Only 1 real root which isn't a stationary point")
        return Discriminant
    }
}
,QuarticDiscriminant=(a,b,c,d,e)=>{//y=ax⁴+bx³+cx²+dx+e
    if(a==0)
        return CubicDiscriminant(b,c,d,e)
    else{//https://en.wikipedia.org/wiki/Discriminant#Degree_4
        const Discriminant=256*a**3*e**3-192*a**2*b*d*e**2-128*a**2*c**2*e**2+144*a**2*c*d**2*e-27*a**2*d**4+144*a*b**2*c*e**2-6*a*b**2*d**2*e-80*a*b*c**2*d*e+18*a*b*c*d**3+16*a*c**4*e-4*a*c**3*d**2-27*b**4*e**2+18*b**3*c*d*e-4*b**3*d**3-4*b**2*c**3*e+b**2*c**2*d**2
        if(Discriminant==0)
            console.log('• At least 1 stationary point is also a root')
        else if(Discriminant>0)
            console.log('• Roots are either all real or all complex')
        else//Discriminant<0
            console.log('• 2 real roots and 2 complex roots')
        return Discriminant
    }
}

//Note: It has been proven in 1824 in the Abel–Ruffini theorem that there cannot be a general solution for polynomials of degrees greater than 4

/*--------------Convert Bases--------------*/
/*
    There are few ways to convert between bases
    The fastest way to convert, which also never result in non-terminating repeating decimals involves replacing each character with others,
    and therefore doesn't involve any actual math calculations.

    For 2 bases to quality to this efficient conversion, their BaseLog needs to be an integer.
    Their BaseLog integer specifies the number of characters which are replaced in the smaller base from a single character in the larger base.
    2 Bases can also use this method if thier BaseLog isn't an integer, but they share another base to which they seperately have integer BaseLog,
    e.g. Base8 Octal and Base16 Hexadecimal are efficiently conveted between via Base2 Binary.
*/

,Base4ToBase2=InputNumber=>{
    InputNumber=String(InputNumber);let i=-1,Point=false,Result=''
    if(InputNumber[0]=='-'){InputNumber=InputNumber.slice(1);Result='-'}
    const L_1=InputNumber.length-1
    do{
        const Digit=InputNumber[++i]
        switch(Digit){// BaseLog(2,4)=2, hence each digit in Base4 is replaced with exactly 2 digits in Base2
            case '0':Result+='00';break
            case '1':Result+='01';break
            case '2':Result+='10';break
            case '3':Result+='11';break
            case '-':return"Can only have a minus sign '-' at the start"
            case '.':if(Point){return"Can't have multiple decimal points '.'"}else{Result+='.';Point=true;break}
            default: return"Character '"+Digit+"' is invalid"
        }
    }while(i<L_1)
    return Result
}
,Base8ToBase2=InputNumber=>{
    InputNumber=String(InputNumber);let i=-1,Point=false,Result=''
    if(InputNumber[0]=='-'){InputNumber=InputNumber.slice(1);Result='-'}
    const L_1=InputNumber.length-1
    do{
        const Digit=InputNumber[++i]
        switch(Digit){// BaseLog(2,8)=3, hence each digit in Base8 is replaced with exactly 3 digits in Base2
            case '0':Result+='000';break
            case '1':Result+='001';break
            case '2':Result+='010';break
            case '3':Result+='011';break
            case '4':Result+='100';break
            case '5':Result+='101';break
            case '6':Result+='110';break
            case '7':Result+='111';break
            case '-':return"Can only have a minus sign '-' at the start"
            case '.':if(Point){return"Can't have multiple decimal points '.'"}else{Result+='.';Point=true;break}
            default: return"Character '"+Digit+"' is invalid"
        }
    }while(i<L_1)
    return Result
}
// This allows converting both integers and decimals from any base to any base in the range of 2-36
,ConvertBases=(InputNumber,InputBase,OutputBase)=>{
    if(!Number.isInteger(InputBase)||!Number.isInteger(OutputBase)||InputBase>36||InputBase<2||OutputBase>36||OutputBase<2){
        return'InputBase & OutputBase must be whole numbers between 2-36'
    }else if(InputBase==OutputBase){
        console.log('InputBase = OutputBase');return InputNumber
    }else{
        const AllowedCharcters=['.','-','0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z']
        ,Base10=InputBase==10?InputNumber:parseInt(InputNumber,InputBase)
        ,StringInput=String(InputNumber)

        InputBase==36||AllowedCharcters.splice(InputBase-36)
        let L=StringInput.length
        do{
            const Char=StringInput[--L]
            if(!AllowedCharcters.includes(Char))return"Character '"+Char+"' is invalid in base "+InputBase
        }while(L>0)

        const Result=Base10.toString(OutputBase),ResultNumber=Number(Result)
        return isNaN(ResultNumber)?Result:ResultNumber
    }
}

/*--------------Convert Units--------------*/
,ConvertMassUnits=(InputNumber,UnitIndex)=>{ // UnitIndex would be one of the keys from the Units object such as 'kg' or 'lb'
    UnitIndex==undefined&&(UnitIndex='g') // Gram is default if no unit is specified
    const Units={
        // Mass UnitIndices:

        // British Imperial:
        'gr': 480/31.1034768 // Grain
        ,'dwt': 20/31.1034768 // Pennyweight
        ,'ozt': 1/31.1034768 // Troy Ounce

        // Metric:
        ,'ng': 10**9 // Nanogram
        ,'mcg': 10**6 // Microgram , A.K.A. 'μg', but 'μ' isn't used here because non-UTF-8 characters sometimes render badly in some consoles
        ,'mg': 1000 // Milligram
        ,'ct': 5 // Carat
        ,'g': 1 // Gram - reference
        ,'kg': 0.001 // Kilogram
        ,'t': 10**-6 // Tonne

        // American Imperial:
        ,'oz': 16/453.59237 // Ounce
        ,'lb': 1/453.59237 // Pound
        ,'st': 1/14/453.59237 // Stone
        ,'tn': 7/14000/453.59237 // US Ton
        ,'LT': 7/14000/453.59237/1.12 // Imperial Long Ton
    }
    ,Ratio=InputNumber/Units[UnitIndex];Units[UnitIndex]=InputNumber
    Object.keys(Units).forEach(Key=>Key==UnitIndex||(Units[Key]=Number((Units[Key]*Ratio).toPrecision(4))))
    return Units
}

/*--------------Fraction--------------*/
,DecimalToFraction=d=>{// d = Decimal
    const ε=1e-10,S=Math.sign(d)// S = sign, meaning -1, 0 or 1
    let ABS=Math.abs(d)
    const G=ABS>1;G&&(ABS**=-1)
    if(isNaN(S))return'Please input a number'
    let a=Math.floor(ABS),i=h2=N=0,D=k2=1,y=ABS-a,x,h,k

    while(y>ε){
        if(++i==100)return'100 iterations passed without finding a ratio of integers, so the input number is probably irrational'
        x=1/y;a=Math.floor(x);y=x-a
        h=a*D+h2;h2=D;D=h
        k=a*N+k2;k2=N;N=k
    }
    console.log(i,' iterations');return G!=true?[S*N,D]:[S*D,N]// [ N = Numerator , D = Denominator ]
}/*e.g. DecimalToFraction(76.92) ➜ [1923,25]; DecimalToFraction(-0.0314) ➜ [-157,5000]
    The uniquely nice thing about this function is that the output is equal to the input,so you can easily verify
    the outputs are correct by entering them into a terminal to get the input, e.g. 1923/25 ➜ 76.92 , -157/5000 ➜ -0.0314
*/

/*--------------Logarithms & Exponentials--------------*/ // log(😅) = 💧log(😄)
,BaseLog=(Base,Num)=>Math.log(Num)/Math.log(Base) // BaseLog_Base(Number)

/*--------------Iterative Taylor/Maclaurin Series--------------*/
/* Note: The functions below all have an equivilant Math API function built into JS, but I consider these as Redundant Syntactic Sugar, so here's what they would look like if we only had the JS syntax we acutally NEEDED for basic functionality

x = number , i = # iterations (more takes more time, but increases accuracy) 

*/

,exp=(x,i)=>{// Exponential: Math.exp(x) | Math.E**x | e^x
    //e^x = 1 + x + x^2/2! + x^3/3! + x^4/4! + ..
    let j=1,N=r=x
    if(i==undefined){// if no i is entered
        let p
        do{p=r;++j;N*=x/j;r+=N}while(p!=r&&![0,NaN,Infinity].includes(r))
        console.log(j-2,'iterations')
    }else if(!Number.isInteger(i)||i<0)return'i must be either zero or a positive integer!'
    else// if i is inputted as a positive integer
        while(j++<=i){N*=x/j;r+=N}
    return Number((r+1).toFixed(14))
}

// Math.E = exp(1) | 2.718281828459045
,EXPM1=(x,i)=>exp(x,i)-1 /* Math.expm1(x) , e.g. EXPM1(1) ➜ 1.71828182845905 , EXPM1(-0.5) ➜ -0.39346934028737
    note that this could've been achieved slightly more efficiently by simply not adding +1 to r, see exp functions above */

/*--------------Other Redundant Syntactic Sugar--------------*/
//Following the Iterative Taylor/Maclaurin Series, here are other simpler Redundant Syntactic Sugar which could've been easily defined in a customised way as opposed to being included in the official syntax:

,IsInt=N=>(N|0)==N /* Number.isInteger(N) , Alternatively: N%1==0, but bitwise operators are faster.
    e.g. IsInt(-3) ➜ true , IsInt(1.2) ➜ false , IsInt(Infinity) ➜ false */

,IsNumeric=N=>!isNaN(N-0) // Basically custom isFinite(N), but IsNumeric(Infinity) ➜ true
,IsFinite=N=>IsNumeric(N)&&N!=Infinity&&N!=-Infinity /* isFinite(N), e.g. IsFinite(Infinity) ➜ false
   IsFinite(-Infinity) ➜ false , IsFinite(NaN) ➜ false , IsFinite(undefined) ➜ false
   IsFinite(Number.MAX_VALUE) ➜ true , IsFinite('0') ➜ true , IsFinite(null) ➜ true
*/
,Sign=N=>N>0?1:N<0?-1:N-0 /* Math.sign(N), e.g. Sign(-0.1) OR Sign(-Infinity) ➜ -1 , Sign(23.4) ➜ OR Sign(Infinity) ➜ 1
    Sign(0) OR Sign(null) ➜ 0 , Sign() OR Sign(undefined) OR Sign('string') OR Sign(NaN) OR Sign([0,1]) ➜ NaN
    Alternatively: !!N|N>>31 but doesn't work for 0 > N > -1, -Infinity, NaN, undefined, strings and arrays */

,ABS=N=>N<0?-1*N:N-0 // Math.abs(N) or |N|, e.g. ABS(-1.5) ➜ 1.5, ABS(2.3) ➜ 2.3
,ABS_Int=N=>{const n=N>>31;return (N^n)-n} /* |N| but faster and only returns integers, 
    e.g. ABS_Int(-1.5) ➜ 1, ABS_Int(2.3) ➜ 2 */

// Methods that turn a fraction into one of two consecutive integers
,Round=N=>N>0?N+0.5|0:IsInt(2*N)?N|0:N-0.5|0 // Math.round(N), e.g. Round(-1.5) ➜ -1, Round(2.3) ➜ 2

,Floor=N=>(N|0)-(N<(N|0)) /* Math.floor(N), Alternatively: (N|0)-(N>>31&1), but doesn't work for 0 > N > -1
ABS(N)==Infinity?N:N<0?(N|0)-1:N|0, but bitwise is faster
    e.g. Floor(0) ➜ 0 , Floor(-4.5) ➜ -5 , Floor(4.5) ➜ 4 */
,Ceiling=N=>(N|0)+(N>(N|0)) /* Math.ceil(N), Alternatively: (N|0)+(N>>31^1), but doesn't work for 0 > N > -1
ABS(N)==Infinity?N:N<0?N|0:(N|0)+1
    e.g. Ceiling(0) ➜ 0 , Ceiling(-4.5) ➜ -4 , Ceiling(4.5) ➜ 5 */

,Trunc=N=>N|0 /* Math.trunc(N), e.g. Trunc(-1.5) ➜ -1 , Trunc(2.3) ➜ 2 , Trunc(-0.1) ➜ 0
    Each of the 7 bitwise operators has a way to truncate on its own to Int32:
    N^0 , ~~N , N&-1 , N<<0 , N>>0 . N>>>0 only works for N >= 0 */
,TruncOut=N=>(N|0)+Sign(N) /* Custom function. Whereas Trunc gets closer to 0, TruncOut gets out and away from 0. 
   e.g. TruncOut(-1.5) ➜ -2 , TruncOut(2.3) ➜ 3  */

,POW=(a,b)=>a**b // Math.pow(a,b), e.g. POW(-2,3) ➜ -8
,IMUL=(a,b)=>(a|0)*(b|0) // Math.imul(a,b), e.g. IMUL(-2.3,3.9) ➜ -6 , basically multiplys the integers

,Max=(a,b)=>a>b?a:b // Math.max(a,b), e.g. Max(0,-Infinity) ➜ 0
,Min=(a,b)=>a<b?a:b // Math.min(a,b), e.g. Min(0,-Infinity) ➜ -Infinity
,Max_Int=(a,b)=>{const n=(a-b)>>31;return b&n|a&~n}/* Max(a,b) but faster and only returns integers, 
    e.g. Max_Int(6.5,-3.5) ➜ 6 */
,Min_Int=(a,b)=>{const n=(a-b)>>31;return a&n|b&~n} /* Min(a,b) but faster and only returns integers, 
    e.g. Min_Int(6.5,-3.5) ➜ -3 */

,SQRT=N=>N**0.5 // Math.sqrt(N) , e.g. SQRT(64) ➜ 8 , Note this result is ±
// Math.SQRT2 = SQRT(2) | 1.4142135623730951 , // Math.SQRT1_2 = SQRT(0.5) | 0.7071067811865476
,CBRT=N=>N**(1/3) // Math.cbrt(N) , e.g. CBRT(64) ➜ 4
,Hypotenuse=(O,A)=>SQRT(O**2+A**2) // Math.hypot(O,A) where O = Opposite & A = Adjacent, e.g. Hypotenuse(3,4) ➜ 5

// Note: you can add 'isNaN(N)?NaN:' at the beginning of each of these, but it's not necessary

,MachinsPI=i=>{// Math.PI = MachinsPI() | 3.141592653589793
    if(i==undefined)i=1000//default iterations
    else if(!Number.isInteger(i)||i<0)return'i must be either zero or a positive integer!'
    let π=0,p,k=-1
    while(p!=π&&++k<i){p=π;π+=(4/(8*k+1)-2/(8*k+4)-1/(8*k+5)-1/(8*k+6))/(16**k)}
    console.log(i,'iterations')
    return π
}

/*--------------Other Operators, Not Native Redundant Syntactic Sugar Methods In JS--------------*/
// Note: anytime a function's name starts with Is, it means it returns true or false

,IsSameSign=(a,b)=>(a^b)>=0 // e.g. SameSign(-43,-5.6) ➜ true , SameSign(0,-5.6) ➜ false

,IsOdd=N=>IsInt(N)&&(N&1)==1 /* true means odd AND indivisible by 2
   e.g. IsOdd(32) ➜ false , IsOdd(33) ➜ true , IsOdd(36) ➜ false , IsOdd(Infinity) ➜ false */
,IsEven=N=>IsInt(N)&&(N&1)==0 /* true means even AND divisible by 2
   e.g. IsEven(2.3) ➜ false , IsEven(0) ➜ true , IsEven(-Infinity) ➜ false */

,IsPowerOf2=N=>IsInt(N)&&N>0&&(N&(N-1))==0 /* e.g. IsPowerOf2(32) ➜ true , IsPowerOf2(36) ➜ false
    Note that techically you can use BaseLog(2,N) and it'll return the exact power, but this is faster.
    BaseLog(B,N) can be used not just for base 2, but also for other bases like decimals */

,IsDivisibleBy=(N,B)=>N%B==0 /* Is N divisible by B? , e.g. IsDivisibleBy(32,2) ➜ true
    IsDivisibleBy(36,2) ➜ true , IsDivisibleBy(33,2) ➜ false , IsDivisibleBy(33,3) ➜ true
    IsDivisibleBy(25,5) ➜ true , IsDivisibleBy(26,5) ➜ false , IsDivisibleBy(25.1,5.2) ➜ false */

,QuotientDivision=(N,D)=>N/D|0 // N = Numerator , D = Denominator, e.g. QuotientDivision(-7,2) ➜ -3

/* Swap the values of two variables such that a=b & b=a
    It's easier to swap without making function, because we're trying to change the original variables, not return new ones

    Temporary Variable: const c=a;a=b;b=c
    Destructuring Assignment: [a,b]=[b,a]
    // these work for every type: fractions|decimal numbers, arrays, strings, boolean, etc
    e.g. let a = '6.5' , b = [-3.5] ; c=a;a=b;b=c OR [a,b]=[b,a] ➜ [ a ➜ [-3.5] ; b ➜ '6.5' ]

    XOR: a^=b;b^=a;a^=b // this only works on integers (or rather only returns integers) but it's faster
    e.g. let a = '6.5' , b = [-3.5] ; a^=b;b^=a;a^=b ➜ [ a ➜ -3 ; b ➜ 6 ]
*/

/*--------------Bitwise and Logical equivalents of each other--------------*/
/* The reason for these functions is that there are 4 logic gate bitwise operators (&, |, ~, ^) 
    and only 3 logical operators (&&, ||, !), so I'm filling the gap here. 
    Note that logical functions return true|false while bitwise functions return 1|0 
*/
,Logical_XOR=(a,b)=>a!=b /* a^b , returns true if the two inputs are unequal, otherwise returns false
    Logical_XOR('Try string','Try string') ➜ false , Logical_XOR('Try string','Another string') ➜ true */

,Bitwise_IsEqual=(a,b)=>2+~(a^b) /* a==b , returns 1 if the two inputs are equal, otherwise returns another integer
    Bitwise_IsEqual(-23.4,8.7) ➜ 32 , Bitwise_IsEqual(-0.5,0) ➜ 1 because both are truncated */

/*--------------Strings: Redundant Syntactic Sugar Methods Native In JS--------------*/
// S = String , C = Character
,TrimStart=(S,C)=>{
    if(C==undefined)C=' ' // if no C is entered, then S.trimStart()
    let s=0;while(S[s]==C)++s
    return S.slice(s)
}// e.g. TrimStart('  Try  ') ➜ 'Try  ' , TrimStart('00034E50.3C0120000','0') ➜ '34E50.3C0120000'
,TrimEnd=(S,C)=>{
    if(C==undefined)C=' ' // if no C is entered, then S.trimEnd()
    let s=-1;while(S.at(s)==C)--s
    return s==-1?S:S.slice(0,s+1)
}// e.g. TrimEnd('  Try  ') ➜ '  Try' , TrimEnd('00034E50.3C0120000','0') ➜ '00034E50.3C012'
,Trim=(S,C)=>{
    if(C==undefined)return TrimStart(TrimEnd(S)) // if no C is entered, then S.trim()
    return TrimStart(TrimEnd(S,C),C)
}/* e.g. Trim('  Try  ') ➜ 'Try' , Trim('00034E50.3C0120000','0') ➜ '34E50.3C012'
    Efficient practices:
        - don't measure .length of whole string if you don't have to
        - use a variable s and slice only once, as opposed to slice once for every character that needs trimming
        - use s+1 as opposed to ++s when you're done using s
        - for Trim, TrimEnd first and only then TrimStart to save on re-indexing characters
*/

,Replace=(SA,P,R)=>{/* Equivilant to the SA.replace(P,R) method but also works with arrays, not just strings.
    Replaces the 1st occurrence of Pattern P with Replacement R. SA is either String '' OR Array []. */
    const i=SA.indexOf(P)
    if(Array.isArray(SA)){//Array
        i==-1||(SA[i]=R);return SA
    }//else if String
        return i==-1?SA:`${SA.slice(0,i)}${R}${SA.slice(i+P.length)}`
}/*e.g. Replace(['S','A','$','S','A','h'],'A','g') ➜ ['S','g','$','S','A','h']
    Replace('SA$SAh','SA','g') ➜ 'g$SAh' , Replace('SA$SAh','','g') ➜ 'gSA$SAh'
    Replace('SA$SAh','D','g') ➜ 'SA$SAh' */
,ReplaceAll=(SA,P,R)=>{/* Equivilant to the SA.replaceAll(P,R) method but also works with arrays, not just strings.
    Replaces ANY & ALL occurrences of Pattern P with Replacement R. SA is either String '' OR Array []. */
    if(Array.isArray(SA)){//Array
        for(let i=SA.indexOf(P);i!=-1;i=SA.indexOf(P,i+1))SA[i]=R
        return SA
    }//else if String
        const p=P.length;if(p==0)return R+SA.split('').join(R)+R
        let i=SA.indexOf(P),AC='' // AC = Already Checked|Changed
        while(i!=-1){
            AC+=SA.slice(0,i)+R;SA=SA.slice(i+p);i=SA.indexOf(P)
        }
        return AC+SA
}/* e.g. ReplaceAll(['S','A','$','S','A','h'],'A','g') ➜ ['S','g','$','S','g','h']
    ReplaceAll('SA$SAh','SA','g') ➜ 'g$gh' , ReplaceAll('SA$SAh','D','g') ➜ 'SA$SAh'
    ReplaceAll('SA$SAh','','g') ➜ 'gSgAg$gSgAghg'
*/

,ToUpperCase=S=>{// S.toUpperCase()
    const L=S.length;let s=''
    for(let i=-1;++i<L;){
        const c=S[i] // c = character
        switch(c){
            case'e':s+='E';break;case't':s+='T';break;case'a':s+='A';break;case'o':s+='O';break
            case'i':s+='I';break;case'n':s+='N';break;case's':s+='S';break;case'h':s+='H';break
            case'r':s+='R';break;case'd':s+='D';break;case'l':s+='L';break;case'c':s+='C';break
            case'u':s+='U';break;case'm':s+='M';break;case'w':s+='W';break;case'f':s+='F';break
            case'g':s+='G';break;case'y':s+='Y';break;case'p':s+='P';break;case'b':s+='B';break
            case'v':s+='V';break;case'k':s+='K';break;case'j':s+='J';break;case'x':s+='X';break
            case'q':s+='Q';break;case'z':s+='Z';break;default:s+=c 
        }
    }
    return s
}// e.g. ToUpperCase('Hello World! אב 🙂 ,./"`@#$%^&*-=+') ➜ 'HELLO WORLD! אב 🙂 ,./"`@#$%^&*-=+'
,ToLowerCase=S=>{// S.toLowerCase()
    const L=S.length;let s=''
    for(let i=-1;++i<L;){
        const c=S[i] // c = character
        switch(c){
            case'E':s+='e';break;case'T':s+='t';break;case'A':s+='a';break;case'O':s+='o';break
            case'I':s+='i';break;case'N':s+='n';break;case'S':s+='s';break;case'H':s+='h';break
            case'R':s+='r';break;case'D':s+='d';break;case'L':s+='l';break;case'C':s+='c';break
            case'U':s+='u';break;case'M':s+='m';break;case'W':s+='w';break;case'F':s+='f';break
            case'G':s+='g';break;case'Y':s+='y';break;case'P':s+='p';break;case'B':s+='b';break
            case'V':s+='v';break;case'K':s+='k';break;case'J':s+='j';break;case'X':s+='x';break
            case'Q':s+='q';break;case'Z':s+='z';break;default:s+=c 
        }
    }
    return s
}// e.g. ToLowerCase('Hello World! אב 🙂 ,./"`@#$%^&*-=+') ➜ 'hello world! אב 🙂 ,./"`@#$%^&*-=+'
/*
Note: there are 2 efficiencies of customising ToUpperCase and ToLowerCase, 
instead of using the Redundant Syntactic Sugar Methods Native In JS of .toUpperCase() & .toLowerCase()

1) you can exclude from this switch letters of other alphabets such as Greek i.e. 'αβδΠΣΩ'
    if you weren't going to use those other non-English letters anyway

2) Sorting out letters in the switch from the most frequently used in literature to the least common,
    as opposed to sorting them alphabetically
*/

/*--------------Strings: Other, Not Redundant Syntactic Sugar Methods Native In JS--------------*/
// Key: S = String

,ReverseCases=S=>{// Replaces capital letters with lowercase and vice versa. Leaves all other characters unchanged.
    const L=S.length;let s='' // s = new string
    for(let i=-1;++i<L;){
        const c=S[i],U=c.toUpperCase() // c = character
        s+=c!=U?U:c.toLowerCase() /* it's more efficient to not even try to convert toUpperCase if it's not needed.
           Capitals were selected first because it is more likely for a character to already be lowercase */
    }
    return s
}//e.g. ReverseCases('Hello World! ,./"`@#$%^&*-=+ αβΣאב❤') ➜ 'hELLO wORLD! ,./"`@#$%^&*-=+ ΑΒσאב❤'

,Acronym=S=>{// Returns the 1st letter of each word in a string S
    if(typeof S!='string')return'Please enter a string'
    S=S.trim()
    let i=S.indexOf(' '),C=S[0] // C = already Checked/Changed

    while(i!=-1){S=S.slice(i+1).trimStart();C+=S[0];i=S.indexOf(' ')}
    return C
}//e.g. Acronym('As Soon   As Possible') ➜ 'ASAP' , Acronym(' Do It Yourself ') ➜ 'DIY'

,NumberOfCharacters=S=>S.length // e.g. NumberOfCharacters('e3ΠΔλθτεαδφξμβζΞΛΨΩΣאב❤') ➜ 23
,ByteSize=S=>new TextEncoder().encode(S).length /* e.g. ByteSize('e3ΠΔλθτεαδφξμβζΞΛΨΩΣאב❤') ➜ 45
Alternatively:
•  ByteSize=S=>new Blob([S]).size , but this requires const {Blob}=require('buffer') ahead of this function if done in NodeJS
•  ByteSize=S=>Buffer.from(S).length , but this only works in NodeJS, not HTML
Both these alternatives do not predict the result ("eager evaluation") in terminal/console, hence TextEncoder().encode() is always preferred
*/