Last active
December 21, 2025 12:20
-
-
Save RackofLambda/343939f87b8e1f80b57f9a1b43c4b949 to your computer and use it in GitHub Desktop.
A collection of Microsoft Excel LAMBDA functions related to Prime Factorization.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /* List of LAMBDA functions in this collection: | |
| -------------------------------------------- | |
| ISPRIME -------->> Determines if a number is prime. | |
| FACTORS -------->> Returns all factors of a number. | |
| PF ------------->> (recursive) Returns the prime factorization of a number. | |
| PF_LCM --------->> Returns the least common multiple of integers. Extends the native LCM return limits from 2^53 to 10^308. | |
| */ | |
| /* FUNCTION NAME: ISPRIME | |
| DESCRIPTION: Determines if a number is prime. | |
| SYNTAX: =ISPRIME(number) | |
| ARGUMENTS: number (required) | |
| EXAMPLES: =ISPRIME(97) | |
| =ISPRIME(A2) | |
| =MAP(A2:A1000,ISPRIME) | |
| =LET(a,SEQUENCE(10000),FILTER(a,MAP(a,ISPRIME))) | |
| */ | |
| ISPRIME = LAMBDA(number, | |
| IF( | |
| OR(number < 2, number <> INT(number), AND(number > 2, ISEVEN(number))), | |
| FALSE, | |
| OR(number = 2, AND(MOD(number, SEQUENCE(ROUNDUP(SQRT(number), 0) - 1,, 2)))) | |
| ) | |
| ); | |
| /* FUNCTION NAME: FACTORS | |
| DESCRIPTION: Returns all factors of a number. | |
| SYNTAX: =FACTORS(number,[paired]) | |
| ARGUMENTS: number (required) | |
| [paired] (Boolean, optional) - determines the output format. | |
| 0 or FALSE - sequential (default) | |
| 1 or TRUE - paired | |
| EXAMPLES: =FACTORS(1024) | |
| =FACTORS(1024,TRUE) | |
| =FACTORS(A2) | |
| =FACTORS(A2:A1000,1) | |
| */ | |
| FACTORS = LAMBDA(number,[paired], | |
| MAP( | |
| number, | |
| LAMBDA(k, | |
| IF( | |
| OR(k < 1, MOD(k, 1)), | |
| NA(), | |
| ARRAYTOTEXT( | |
| LAMBDA(j, IF(paired, "(" & BYROW(TAKE(HSTACK(j, SORT(j,, -1)), ROUNDUP(ROWS(j) / 2, 0)), ARRAYTOTEXT) & ")", j))( | |
| LAMBDA(i, FILTER(i, NOT(MOD(k, i))))(SEQUENCE(k)) | |
| ) | |
| ) | |
| ) | |
| ) | |
| ) | |
| ); | |
| /* FUNCTION NAME: PF | |
| DESCRIPTION: (recursive) Returns the prime factorization of a number. | |
| PREREQUISITES: ISPRIME | |
| SYNTAX: =PF(number,[opt]) | |
| =PF(number,[opt],[p],[k]) | |
| ARGUMENTS: number (required) - whole number, greater than 1. | |
| [opt] (integer, optional) - determines the output format. | |
| 0 - prime factors (default) | |
| 1 - prime factors with total | |
| 2 - exponential | |
| 3 - exponential with total | |
| -1 - unmask prime numbers (for internal use with the PF_LCM function shown below) | |
| [p] (vertical vector, internal use only) - list of prime numbers used to find the lowest prime factor for the current iteration. | |
| - {2;3;5;7;11;13;17;19;23;29} (default) - adjust the row separators (;) to match your system's regional settings, if needed. | |
| [k] (text, internal use only) - accumulated results (prime factors) from the previous iteration(s). | |
| EXAMPLES: =PF(A2) | |
| =PF(A2,2) | |
| =PF(101,1) | |
| =PF(99999999,3) | |
| =MAP(A2:A1000,PF) | |
| =MAP(A2:A1000,LAMBDA(v,PF(v,2))) | |
| =MAP(SEQUENCE(999,,2),LAMBDA(v,PF(v,1))) | |
| =MAP(SEQUENCE(999,,2),LAMBDA(v,PF(v,3))) | |
| */ | |
| PF = LAMBDA(number,[opt],[p],[k], | |
| IF( | |
| OR(number < 2, number <> INT(number)), | |
| NA(), | |
| IF( | |
| ISPRIME(number), | |
| IF( | |
| ISOMITTED(k), | |
| CHOOSE(opt + 2, number, "prime", number & " = prime", "prime", number & " = prime"), | |
| LET( | |
| k, k & " x " & number, | |
| CHOOSE( | |
| opt + 2, | |
| k, | |
| k, | |
| PRODUCT(--TEXTSPLIT(k, "x")) & " = " & k, | |
| LET(v, --TEXTSPLIT(k,, "x"), TEXTJOIN(" * ",, BYROW(GROUPBY(v, v, ROWS, 0, 0), LAMBDA(r, TEXTJOIN("^",, r))))), | |
| LET(v, --TEXTSPLIT(k,, "x"), PRODUCT(v) & " = " & TEXTJOIN(" * ",, BYROW(GROUPBY(v, v, ROWS, 0, 0), LAMBDA(r, TEXTJOIN("^",, r))))) | |
| ) | |
| ) | |
| ), | |
| LET( | |
| p, IF(ISOMITTED(p), {2;3;5;7;11;13;17;19;23;29}, FILTER(p, p <= number)), | |
| f, @FILTER(p, NOT(MOD(number, p))), | |
| IF( | |
| ISNUMBER(f), | |
| PF(number / f, opt, p, TEXTJOIN(" x ", 1, k, f)), | |
| LET(a, SEQUENCE(CEILING.MATH(@TAKE(p, -1), 100) * 2,, 2), PF(number, opt, FILTER(a, MAP(a, ISPRIME)), k)) | |
| ) | |
| ) | |
| ) | |
| ) | |
| ); | |
| /* FUNCTION NAME: PF_LCM | |
| DESCRIPTION: Returns the least common multiple of integers. Extends the native LCM return limits from 2^53 to 10^308. | |
| PREREQUISITES: PF, ISPRIME | |
| SYNTAX: =PF_LCM(number_array) | |
| ARGUMENTS: number_array (required) - an array of 2 or more numbers; if a number is not an integer, it is truncated. | |
| EXAMPLES: =PF_LCM({47045881;594823321}) | |
| =PF_LCM(A2:A3) | |
| =PF_LCM(A2:A100) | |
| =PF_LCM(HSTACK(A2:B2,F2)) | |
| =PF_LCM(VSTACK(A2,A10:A11)) | |
| =PF_LCM(TOCOL((A2:B2,A10:A11))) | |
| */ | |
| PF_LCM = LAMBDA(number_array, | |
| LET( | |
| n, INT(number_array), | |
| IF( | |
| OR(n < 0), | |
| SQRT(-1), | |
| IF( | |
| OR(n = 0), | |
| 0, | |
| IF( | |
| AND(n = 1), | |
| 1, | |
| LET( | |
| t, MAP(UNIQUE(SORT(TOCOL(IFS(n > 1, n), 2))), LAMBDA(v, PF(v, -1))), | |
| j, SEQUENCE(, MAX(LEN(t) - LEN(SUBSTITUTE(t, "x", ))) + 1), | |
| a, TEXTSPLIT(TEXTAFTER("x" & t, "x", j), "x"), | |
| i, TOCOL(IF(ISERROR(a), a, SEQUENCE(ROWS(a))), 2), | |
| v, --TOCOL(a, 2), | |
| r, DROP(GROUPBY(HSTACK(i, v), v, ROWS, 0, 0),, 1), | |
| m, GROUPBY(TAKE(r,, 1), DROP(r,, 1), MAX, 0, 0), | |
| PRODUCT(TAKE(m,, 1) ^ DROP(m,, 1)) | |
| ) | |
| ) | |
| ) | |
| ) | |
| ) | |
| ); | |
| // ALTERNATIVE DEFINITION: | |
| PF_LCM = LAMBDA(number_array, | |
| LET( | |
| k, LCM(number_array), | |
| IF( | |
| IFNA(ERROR.TYPE(k), 0) <> 6, | |
| k, | |
| IF( | |
| OR(number_array < 0), | |
| k, | |
| LET( | |
| n, INT(number_array), | |
| t, MAP(UNIQUE(SORT(TOCOL(IFS(n > 1, n), 2))), LAMBDA(v, PF(v, -1))), | |
| j, SEQUENCE(, MAX(LEN(t) - LEN(SUBSTITUTE(t, "x", ))) + 1), | |
| a, TEXTSPLIT(TEXTAFTER("x" & t, "x", j), "x"), | |
| i, TOCOL(IF(ISERROR(a), a, SEQUENCE(ROWS(a))), 2), | |
| v, --TOCOL(a, 2), | |
| r, DROP(GROUPBY(HSTACK(i, v), v, ROWS, 0, 0),, 1), | |
| m, GROUPBY(TAKE(r,, 1), DROP(r,, 1), MAX, 0, 0), | |
| PRODUCT(TAKE(m,, 1) ^ DROP(m,, 1)) | |
| ) | |
| ) | |
| ) | |
| ) | |
| ); | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment