BaseLibraries/TypescriptClasses
1
0
Fork 0
mirror of https://bitbucket.org/Mattrixwv/typescriptclasses.git synced 2025-12-06 10:23:58 -05:00
Code Issues Packages Projects Releases Wiki Activity

Updated library layout

Browse Source
This commit is contained in:
Mattrixwv
2021-07-13 19:23:15 -04:00
parent e7be27660f
commit bc19ca6ed0
7 changed files with 758 additions and 510 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
ArrayAlgorithms.ts Normal file
View File

@@ -0,0 +1,79 @@
//typescriptClasses/ArrayAlgorithms.ts
//Matthew Ellison
// Created: 07-13-21
//Modified: 07-13-21
//Algorithms for arrays
/*
Copyright (C) 2021 Matthew Ellison
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
//Returns true if array 1 and array 2 elements are the same
export function arrayEquals(array1: any[], array2: any[]): boolean{
//If they aren't the same type they aren't equal
if((typeof array1) != (typeof array2)){
return false;
}
//If they aren't the same length they aren't equal
else if(array1.length != array2.length){
return false;
}
else{
//Loop through every element to see if each one is equal
for(let cnt = 0;cnt < array1.length;++cnt){
//If any element in the same location is different return false
if(array1[cnt] != array2[cnt]){
return false;
}
}
//If every element was the same they are equal
return true;
}
}
//Returns the sum of all elements in the array
export function getSum(ary: number[]): number{
let sum: number = 0;
ary.forEach(a => sum += a);
return sum;
}
export function getSumBig(ary: bigint[]): bigint{
let sum: bigint = 0n;
ary.forEach(a => sum += a);
return sum;
}
//Returns the product of all elements in the array
export function getProd(ary: number[]): number{
//Return 0 if the array is empty
if(ary.length == 0){
return 0;
}
let prod: number = 1;
ary.forEach(a => prod *= a);
return prod;
}
export function getProdBig(ary: bigint[]): bigint{
//Return 0 if the array is empty
if(ary.length == 0){
return 0n;
}
let prod: bigint = 1n;
ary.forEach(a => prod *= a);
return prod;
}

173
Algorithms.ts → NumberAlgorithms.ts
View File

@@ -1,8 +1,8 @@
//typescriptClasses/Algorithms.ts
//typescriptClasses/NumberAlgorithms.ts
//Matthew Ellison
// Created: 10-19-20
//Modified: 03-10-21
//This class holds many algorithms that I have found it useful to keep around
// Created: 07-13-21
//Modified: 07-13-21
//Algorithms for numbers
/*
Copyright (C) 2021 Matthew Ellison
@@ -21,50 +21,9 @@ Copyright (C) 2021 Matthew Ellison
*/
import { SSL_OP_SSLEAY_080_CLIENT_DH_BUG } from "constants";
import { InvalidResult } from "./InvalidResult";
export function arrayEquals(array1: any[], array2: any[]): boolean{
//If they aren't the same type they aren't equal
if((typeof array1) != (typeof array2)){
return false;
}
//If they aren't the same length they aren't equal
else if(array1.length != array2.length){
return false;
}
else{
//Loop through every element to see if each one is equal
for(let cnt = 0;cnt < array1.length;++cnt){
//If any element in the same location is different return false
if(array1[cnt] != array2[cnt]){
return false;
}
}
//If every element was the same they are equal
return true;
}
}
export function sqrtBig(value: bigint): bigint{
if(value < 0n){
throw "Negative numbers are not supported";
}
let k = 2n;
let o = 0n;
let x = value;
let limit = 100;
while(x ** k !== k && x !== o && --limit){
o = x;
x = ((k - 1n) * x + value / x ** (k - 1n)) / k;
}
return x;
}
//Generate an infinite sequence of prime numbers using the Sieve of Eratosthenes
export function* sieveOfEratosthenes(){
//Return 2 the first time, this lets us skip all even numbers later
@@ -98,7 +57,6 @@ export function* sieveOfEratosthenes(){
}
}
}
export function* sieveOfEratosthenesBig(){
//Return 2 the first time, this lets us skip all even numbers later
yield 2n;
@@ -132,6 +90,26 @@ export function* sieveOfEratosthenesBig(){
}
}
//This returns the sqrt of the bigint passed in
export function sqrtBig(value: bigint): bigint{
if(value < 0n){
throw "Negative numbers are not supported";
}
let k = 2n;
let o = 0n;
let x = value;
let limit = 100;
while(x ** k !== k && x !== o && --limit){
o = x;
x = ((k - 1n) * x + value / x ** (k - 1n)) / k;
}
return x;
}
//Returns an array with all Fibonacci numbers up to goalNumber
export function getAllFib(goalNumber: number): number[]{
//Setup the variables
let fibNums: number[] = [];
@@ -185,6 +163,7 @@ export function getAllFibBig(goalNumber: bigint): bigint[]{
return fibNums;
}
//Returns an array with all primes up to goalNumber
export function getPrimes(goalNumber: number): number[]{
let primes: number[] = []; //Holds the prime numbers
let foundFactor: boolean = false; //A flag for whether a factor of the current number has been found
@@ -286,6 +265,7 @@ export function getPrimesBig(goalNumber: bigint): bigint[]{
return primes;
}
//Returns an array with numberOfPrimes prime elements
export function getNumPrimes(numberOfPrimes: number): number[]{
let primes: number[] = []; //Holds the prime numbers
let foundFactor: boolean = false; //A flag for whether a factor of the current number has been found
@@ -387,6 +367,7 @@ export function getNumPrimesBig(numberOfPrimes: bigint): bigint[]{
return primes;
}
//Returns true if possiblePrime is prime
export function isPrime(possiblePrime: number): boolean{
if(possiblePrime <= 3){
return possiblePrime > 1;
@@ -416,6 +397,7 @@ export function isPrimeBig(possiblePrime: bigint): boolean{
return true;
}
//Returns an array with all the factors of goalNumber
export function getFactors(goalNumber: number): number[]{
//You need to get all the primes that could be factors of this number so you can test them
let topPossiblePrime: number = Math.ceil(Math.sqrt(goalNumber));
@@ -485,6 +467,7 @@ export function getFactorsBig(goalNumber: bigint): bigint[]{
return factors;
}
//Returns an array with the prime divisors of goalNumber
export function getDivisors(goalNumber: number): number[]{
let divisors: number[] = [];
@@ -564,37 +547,7 @@ export function getDivisorsBig(goalNumber: bigint): bigint[]{
return divisors;
}
export function getSum(ary: number[]): number{
let sum: number = 0;
ary.forEach(a => sum += a);
return sum;
}
export function getSumBig(ary: bigint[]): bigint{
let sum: bigint = 0n;
ary.forEach(a => sum += a);
return sum;
}
export function getProd(ary: number[]): number{
//Return 0 if the array is empty
if(ary.length == 0){
return 0;
}
let prod: number = 1;
ary.forEach(a => prod *= a);
return prod;
}
export function getProdBig(ary: bigint[]): bigint{
//Return 0 if the array is empty
if(ary.length == 0){
return 0n;
}
let prod: bigint = 1n;
ary.forEach(a => prod *= a);
return prod;
}
//Returns F[goalSubscript]
export function getFib(goalSubscript: number): number{
//Setup the variables
let fibNums: number[] = [1, 1, 0]; //A list to keep track of the Fibonacci numbers. It need only be 3 long because we only need the one we are working on and the last 2
@@ -632,61 +585,6 @@ export function getFibBig(goalSubscript: bigint): bigint{
return fibNums[Number((fibLoc - 1n) % 3n)];
}
//This is a function that creates all permutations of a string and returns a vector of those permutations
export function getPermutations(master: string): string[]{
return getPermutationsHelper(master, 0);
}
function getPermutationsHelper(master: string, num: number): string[]{
let perms: string[] = [];
//Check if the number is out of bounds
if((num >= master.length) || (num < 0)){
//Do nothing and return an empty array
}
//If this is the last possible recurse just return the current string
else if(num == (master.length - 1)){
perms.push(master);
}
//If there are more possible recurses, recurse with the current permutation
else{
let temp: string[] = getPermutationsHelper(master, num + 1);
temp.forEach(str => perms.push(str));
//You need to swap the current letter with every possible letter after it
//The ones needed to swap before will happen automatically when the function recurses
for(let cnt = 1;(num + cnt) < master.length;++cnt){
master = swapString(master, num, (num + cnt));
temp = getPermutationsHelper(master, num + 1);
temp.forEach(str => perms.push(str));
master = swapString(master, num, (num + cnt));
}
//The array is not necessarily in alph-numeric order. So if this is the full array sort it before returning
if(num == 0){
perms.sort();
}
}
//Return the array that was build
return perms;
}
function swapString(str: string, first: number, second: number): string{
let tempStr: string = str.substr(0, first) + str[second] + str.substr(first + 1, second - first - 1) + str[first] + str.substr(second + 1);
return tempStr;
}
//This function returns the number of times the character occurs in the string
export function findNumOccurrence(str: string, ch: string){
let num: number = 0; //Set the number of occurrences to 0 to start
//Loop through every character in the string and compare it to the character passed in
for(let strCh of str){
//If the character is the same as the one passed in increment the counter
if(strCh == ch){
++num;
}
}
//Return the number of times the character appeared in the string
return num;
}
//This function returns the GCD of the two numbers sent to it
export function gcd(num1: number, num2: number){
while((num1 != 0) && (num2 != 0)){
@@ -727,17 +625,6 @@ export function factorialBig(num: bigint): bigint{
return fact;
}
//Returns true if the string passed in is a palindrome
export function isPalindrome(str: string): boolean{
let rev = str.split("").reverse().join("");
if(str == rev){
return true;
}
else{
return false;
}
}
//Converts a number to its binary equivalent
export function toBin(num: number): string{
return (num >>> 0).toString(2);

89
StringAlgorithms.ts Normal file
View File

@@ -0,0 +1,89 @@
//typescriptClasses/StringAlgorithms.ts
//Matthew Ellison
// Created: 07-13-21
//Modified: 07-13-21
//Algorithms for strings
/*
Copyright (C) 2021 Matthew Ellison
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
//This is a function that creates all permutations of a string and returns a vector of those permutations
export function getPermutations(master: string): string[]{
return getPermutationsHelper(master, 0);
}
function getPermutationsHelper(master: string, num: number): string[]{
let perms: string[] = [];
//Check if the number is out of bounds
if((num >= master.length) || (num < 0)){
//Do nothing and return an empty array
}
//If this is the last possible recurse just return the current string
else if(num == (master.length - 1)){
perms.push(master);
}
//If there are more possible recurses, recurse with the current permutation
else{
let temp: string[] = getPermutationsHelper(master, num + 1);
temp.forEach(str => perms.push(str));
//You need to swap the current letter with every possible letter after it
//The ones needed to swap before will happen automatically when the function recurses
for(let cnt = 1;(num + cnt) < master.length;++cnt){
master = swapString(master, num, (num + cnt));
temp = getPermutationsHelper(master, num + 1);
temp.forEach(str => perms.push(str));
master = swapString(master, num, (num + cnt));
}
//The array is not necessarily in alph-numeric order. So if this is the full array sort it before returning
if(num == 0){
perms.sort();
}
}
//Return the array that was build
return perms;
}
function swapString(str: string, first: number, second: number): string{
let tempStr: string = str.substr(0, first) + str[second] + str.substr(first + 1, second - first - 1) + str[first] + str.substr(second + 1);
return tempStr;
}
//Returns true if the string passed in is a palindrome
export function isPalindrome(str: string): boolean{
let rev = str.split("").reverse().join("");
if(str == rev){
return true;
}
else{
return false;
}
}
//This function returns the number of times the character occurs in the string
export function findNumOccurrence(str: string, ch: string){
let num: number = 0; //Set the number of occurrences to 0 to start
//Loop through every character in the string and compare it to the character passed in
for(let strCh of str){
//If the character is the same as the one passed in increment the counter
if(strCh == ch){
++num;
}
}
//Return the number of times the character appeared in the string
return num;
}

386
TestAlgorithms.ts
View File

@@ -1,7 +1,7 @@
//typescriptClasses/TestAlgorithms.ts
//Matthew Ellison
// Created: 10-19-20
//Modified: 03-12-21
//Modified: 07-13-21
//This class holds many algorithms that I have found it useful to keep around
/*
Copyright (C) 2021 Matthew Ellison
@@ -21,381 +21,33 @@ Copyright (C) 2021 Matthew Ellison
*/
import assert = require("assert");
import { arrayEquals, getAllFib, getAllFibBig, getFactors, getFactorsBig, getPrimes, getPrimesBig, getNumPrimes, getNumPrimesBig,
sqrtBig, getSum, getSumBig, getProd, getProdBig, getDivisors, getDivisorsBig, factorial, factorialBig, isPalindrome, toBin, toBinBig, isPrime, isPrimeBig, sieveOfEratosthenes, sieveOfEratosthenesBig } from "./Algorithms";
import { testArrayEquals, testGetSum, testGetProd } from "./TestArrayAlgorithms";
import { testFactorial, testGCD, testGetAllFib, testGetDivisors, testGetFactors, testGetFib, testGetNumPrimes, testGetPrimes, testIsPrime, testSieveOfEratosthenes, testSqrtBig, testToBin } from "./TestNumberAlgorithms";
import { testFindNumOccurrences, testGetPermutations, testIsPalindrome } from "./TestStringAlgorithms";
function testArrayEquals(){
//Test 1
let ary1: number[] = [];
let ary2: number[] = [];
let correctAnswer = true;
let answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 1 failed");
//Test 2
ary1 = [1, 2, 3, 4, 5];
ary2 = [1, 2, 3, 4, 5];
correctAnswer = true;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 2 failed");
//Test 3
ary1 = [1, 2, 3, 4, 5];
ary2 = [1];
correctAnswer = false;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 3 failed");
//Test 4
ary1 = [1, 2, 3, 4, 5];
ary2 = [6, 2, 3, 4, 5];
correctAnswer = false;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 4 failed");
//Test 5
ary1 = [1, 2, 3, 4, 5];
ary2 = [1, 2, 3, 4, 6];
correctAnswer = false;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 5 failed");
//Test 6
let ary3: string[] = ["test1", "test2"];
let ary4: string[] = ["test1", "test2"];
correctAnswer = true;
answer = arrayEquals(ary3, ary4);
assert.ok((answer == correctAnswer), "arrayEquals test 6 failed");
//Test 7
ary3 = ["test1", "Test2"];
ary4 = ["test1", "test2"];
correctAnswer = false;
answer = arrayEquals(ary3, ary4);
assert.ok((answer == correctAnswer), "arrayEquals test 7 failed");
console.log("testArrayEquals passed");
}
function testSqrtBig(){
//Test 1
let square: bigint = 25n;
let correctAnswer: bigint = 5n;
let answer = sqrtBig(square);
assert.ok((answer == correctAnswer), "sqrtBig test 1 failed");
//Test 2
square = 0n;
correctAnswer = 0n;
answer = sqrtBig(square);
assert.ok((answer == correctAnswer), "sqrtBig test 2 failed");
console.log("testSqrtBig passed");
}
function testSieveOfEratosthenes(){
//Test 1
let sieve = sieveOfEratosthenes();
let correctAnswer: number[] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];
let answer: number[] = [];
for(let cnt = 0;cnt < 25;++cnt){
let prime = sieve.next().value;
if(typeof prime == "number"){
answer.push(prime);
}
}
assert.ok(arrayEquals(answer, correctAnswer), "sieveOfEratosthenes failed");
//Test 2
let bigSieve = sieveOfEratosthenesBig();
let bigCorrectAnswer: bigint[] = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n];
let bigAnswer: bigint[] = [];
for(let cnt = 0;cnt < 25;++cnt){
let prime = bigSieve.next().value;
if(typeof prime == "bigint"){
bigAnswer.push(prime);
}
}
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "sieveOfEratosthenes big failed");
console.log("sieveOfEratosthenes passed");
}
function testGetAllFib(){
//Test 1
let correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89];
let highestNumber = 100;
let answer = getAllFib(highestNumber);
assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 1 failed");
//Test 2
correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]
highestNumber = 1000;
answer = getAllFib(highestNumber);
assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 2 failed");
//Test 3
let bigCorrectAnswer = [1n, 1n, 2n, 3n, 5n, 8n, 13n, 21n, 34n, 55n, 89n];
let bigHighestNumber = 100n;
let bigAnswer = getAllFibBig(bigHighestNumber);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getAllFibBig failed");
console.log("testGetAllFib passed");
}
function testGetPrimes(){
//Test1
let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];
let topNum = 100;
let answer = getPrimes(topNum);
assert.ok(arrayEquals(answer, correctAnswer), "getPrimes number failed");
//Test 2
let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n];
let bigTopNum = 100n;
let bigAnswer = getPrimesBig(bigTopNum);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getPrimesBig failed");
console.log("getPrimes passed");
}
function testGetNumPrimes(){
//Test1
let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];
let numPrimes = 25;
let answer = getNumPrimes(numPrimes);
assert.ok(arrayEquals(answer, correctAnswer), "getNumPrimes number failed");
//Test2
let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n];
let bigNumPrimes = 25n;
let bigAnswer = getNumPrimesBig(bigNumPrimes);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getNumPrimesBig failed");
console.log("getNumPrimes passed");
}
function testIsPrime(){
//Test 1
let num: number = 2;
let correctAnswer: boolean = true;
let answer: boolean = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 1 failed");
//Test 2
num = 97;
correctAnswer = true;
answer = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 2 failed");
//Test 3
num = 1000;
correctAnswer = false;
answer = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 3 failed");
//Test 4
num = 1;
correctAnswer = false;
answer = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 4 failed");
//Test 5
let bigNum: bigint = 2n;
correctAnswer = true;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 1 failed");
//Test 6
bigNum = 97n;
correctAnswer = true;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 2 failed");
//Test 7
bigNum = 1000n;
correctAnswer = false;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 3 failed");
//Test 8
bigNum = 1n;
correctAnswer = false;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 4 failed");
console.log("isPrime passed");
}
function testGetFactors(){
//Test 1
let correctAnswer = [2, 2, 5, 5];
let number = 100;
let answer = getFactors(number);
assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 1 failed");
//Test 2
correctAnswer = [2, 7, 7];
number = 98;
answer = getFactors(number);
assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 2 failed");
//Test 3
let bigCorrectAnswer = [2n, 7n, 7n];
let bigNumber = 98n;
let bigAnswer = getFactorsBig(bigNumber);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getFactors BigInt failed");
console.log("getFactors passed");
}
function testGetDivisors(){
//Test 1
let correctAnswer: number[] = [1, 2, 4, 5, 10, 20, 25, 50, 100];
let topNum: number = 100;
let answer: number[] = getDivisors(topNum);
assert.ok(arrayEquals(answer, correctAnswer), "getDivisors number failed");
//Test 2
let bigCorrectAnswer: bigint[] = [1n, 2n, 4n, 5n, 10n, 20n, 25n, 50n, 100n];
let bigTopNum: bigint = 100n;
let bigAnswer: bigint[] = getDivisorsBig(bigTopNum);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getDivisors BigInt failed");
console.log("getDivisors passed");
}
function testGetSum(){
//Test 1
let correctAnswer: number = 0;
let numbers: number[] = [];
let answer: number = getSum(numbers);
assert.ok((correctAnswer == answer), "getSum number 1 failed");
//Test 2
correctAnswer = 118;
numbers = [2, 2, 3, 3, 4, 4, 100];
answer = getSum(numbers);
assert.ok((correctAnswer == answer), "getSum number 2 failed");
//Test 3
let bigCorrectAnswer: bigint = 118n;
let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n];
let bigAnswer: bigint = getSumBig(bigNumbers);
assert.ok((bigCorrectAnswer == bigAnswer), "getSumBig failed");
console.log("getSum passed");
}
function testGetProd(){
//Test 1
let correctAnswer: number = 0;
let numbers: number[] = [];
let answer: number = getProd(numbers);
assert.ok((correctAnswer == answer), "getProd number 1 failed");
//Test 2
correctAnswer = 57600;
numbers = [2, 2, 3, 3, 4, 4, 100];
answer = getProd(numbers);
assert.ok((correctAnswer == answer), "getProd number 2 failed");
//Test 3
let bigCorrectAnswer: bigint = 57600n;
let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n];
let bigAnswer: bigint = getProdBig(bigNumbers);
assert.ok((bigCorrectAnswer == bigAnswer), "getProdBig failed");
console.log("getProd passed");
}
function testFactorial(){
//Test 1
let num: number = 1;
let correctAnswer: number = 1;
let answer: number = factorial(num);
assert.ok((correctAnswer == answer), "factorial number 1 failed");
//Test 2
num = 10;
correctAnswer = 3628800;
answer = factorial(num);
assert.ok((correctAnswer == answer), "factorial number 2 failed");
//Test 3
num = -5;
correctAnswer = 1;
answer = factorial(num);
assert.ok((correctAnswer == answer), "factorial number 3 failed");
//Test 4
let numBig: bigint = 1n;
let correctAnswerBig: bigint = 1n;
let answerBig = factorialBig(numBig);
assert.ok((correctAnswerBig == answerBig), "factorialBig number 1 failed");
console.log("factorial passed");
}
function testIsPalindrome(){
//Test 1
let str: string = "101";
let correctAnswer: boolean = true;
let answer: boolean = isPalindrome(str);
assert.ok((correctAnswer == answer), "isPalindrome number 1 failed");
//Test 2
str = "100";
correctAnswer = false;
answer = isPalindrome(str);
assert.ok((correctAnswer == answer), "isPalindrome number 2 failed");
//Test 3
str = "";
correctAnswer = true;
answer = isPalindrome(str);
assert.ok((correctAnswer == answer), "isPalindrome number 3 failed");
console.log("isPalindrome passed");
}
function testToBin(){
//Test 1
let num: number = 7;
let correctAnswer: string = "111";
let answer: string = toBin(num);
assert.ok((correctAnswer == answer), "toBin number 1 failed");
//Test 2
num = 0;
correctAnswer = "0";
answer = toBin(num);
assert.ok((correctAnswer == answer), "toBin number 2 failed");
//Test 3
num = 1000000;
correctAnswer = "11110100001001000000";
answer = toBin(num);
assert.ok((correctAnswer == answer), "toBin number 3 failed");
//Test 4
let numBig: bigint = 7n;
correctAnswer = "111";
answer = toBinBig(numBig);
assert.ok((correctAnswer == answer), "toBinBig number 1 failed");
//Test 5
numBig = 0n;
correctAnswer = "0";
answer = toBinBig(numBig);
assert.ok((correctAnswer == answer), "toBinBig number 2 failed");
//Test 6
numBig = 1000000n;
correctAnswer = "11110100001001000000";
answer = toBinBig(numBig);
assert.ok((correctAnswer == answer), "toBinBig number 3 failed");
console.log("toBin passed");
}
//Run all of the tests
//Run the array tests
testArrayEquals();
testSqrtBig();
testGetSum();
testGetProd();
//Run the number tests
testSieveOfEratosthenes();
testSqrtBig();
testGetAllFib();
testGetPrimes();
testGetNumPrimes();
testIsPrime();
testGetFactors();
testGetDivisors();
testGetSum();
testGetProd();
testGetFib();
testGCD();
testFactorial();
testIsPalindrome();
testToBin();
//Run the string tests
testGetPermutations();
testIsPalindrome();
testFindNumOccurrences();
console.log("All tests passed");

121
TestArrayAlgorithms.ts Normal file
View File

@@ -0,0 +1,121 @@
//typescriptClasses/TestArrayAlgorithms.ts
//Matthew Ellison
// Created: 07-13-21
//Modified: 07-13-21
//Tests for the array algorithms
/*
Copyright (C) 2021 Matthew Ellison
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
import assert = require("assert");
import { arrayEquals, getProd, getProdBig, getSum, getSumBig } from "./ArrayAlgorithms";
export function testArrayEquals(){
//Test 1
let ary1: number[] = [];
let ary2: number[] = [];
let correctAnswer = true;
let answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 1 failed");
//Test 2
ary1 = [1, 2, 3, 4, 5];
ary2 = [1, 2, 3, 4, 5];
correctAnswer = true;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 2 failed");
//Test 3
ary1 = [1, 2, 3, 4, 5];
ary2 = [1];
correctAnswer = false;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 3 failed");
//Test 4
ary1 = [1, 2, 3, 4, 5];
ary2 = [6, 2, 3, 4, 5];
correctAnswer = false;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 4 failed");
//Test 5
ary1 = [1, 2, 3, 4, 5];
ary2 = [1, 2, 3, 4, 6];
correctAnswer = false;
answer = arrayEquals(ary1, ary2);
assert.ok((answer == correctAnswer), "arrayEquals test 5 failed");
//Test 6
let ary3: string[] = ["test1", "test2"];
let ary4: string[] = ["test1", "test2"];
correctAnswer = true;
answer = arrayEquals(ary3, ary4);
assert.ok((answer == correctAnswer), "arrayEquals test 6 failed");
//Test 7
ary3 = ["test1", "Test2"];
ary4 = ["test1", "test2"];
correctAnswer = false;
answer = arrayEquals(ary3, ary4);
assert.ok((answer == correctAnswer), "arrayEquals test 7 failed");
console.log("testArrayEquals passed");
}
export function testGetSum(){
//Test 1
let correctAnswer: number = 0;
let numbers: number[] = [];
let answer: number = getSum(numbers);
assert.ok((correctAnswer == answer), "getSum number 1 failed");
//Test 2
correctAnswer = 118;
numbers = [2, 2, 3, 3, 4, 4, 100];
answer = getSum(numbers);
assert.ok((correctAnswer == answer), "getSum number 2 failed");
//Test 3
let bigCorrectAnswer: bigint = 118n;
let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n];
let bigAnswer: bigint = getSumBig(bigNumbers);
assert.ok((bigCorrectAnswer == bigAnswer), "getSumBig failed");
console.log("getSum passed");
}
export function testGetProd(){
//Test 1
let correctAnswer: number = 0;
let numbers: number[] = [];
let answer: number = getProd(numbers);
assert.ok((correctAnswer == answer), "getProd number 1 failed");
//Test 2
correctAnswer = 57600;
numbers = [2, 2, 3, 3, 4, 4, 100];
answer = getProd(numbers);
assert.ok((correctAnswer == answer), "getProd number 2 failed");
//Test 3
let bigCorrectAnswer: bigint = 57600n;
let bigNumbers: bigint[] = [2n, 2n, 3n, 3n, 4n, 4n, 100n];
let bigAnswer: bigint = getProdBig(bigNumbers);
assert.ok((bigCorrectAnswer == bigAnswer), "getProdBig failed");
console.log("getProd passed");
}

343
TestNumberAlgorithms.ts Normal file
View File

@@ -0,0 +1,343 @@
//typescriptClasses/TestNumberAlgorithms.ts
//Matthew Ellison
// Created: 07-13-21
//Modified: 07-13-21
//Tests for the number algorithms
/*
Copyright (C) 2021 Matthew Ellison
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
import assert = require("assert");
import { arrayEquals } from "./ArrayAlgorithms";
import { factorial, factorialBig, gcd, gcdBig, getAllFib, getAllFibBig, getDivisors, getDivisorsBig, getFactors, getFactorsBig, getFib, getFibBig, getNumPrimes, getNumPrimesBig, getPrimes, getPrimesBig, isPrime, isPrimeBig, sieveOfEratosthenes, sieveOfEratosthenesBig, sqrtBig, toBin, toBinBig } from "./NumberAlgorithms";
export function testSieveOfEratosthenes(){
//Test 1
let sieve = sieveOfEratosthenes();
let correctAnswer: number[] = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];
let answer: number[] = [];
for(let cnt = 0;cnt < 25;++cnt){
let prime = sieve.next().value;
if(typeof prime == "number"){
answer.push(prime);
}
}
assert.ok(arrayEquals(answer, correctAnswer), "sieveOfEratosthenes failed");
//Test 2
let bigSieve = sieveOfEratosthenesBig();
let bigCorrectAnswer: bigint[] = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n];
let bigAnswer: bigint[] = [];
for(let cnt = 0;cnt < 25;++cnt){
let prime = bigSieve.next().value;
if(typeof prime == "bigint"){
bigAnswer.push(prime);
}
}
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "sieveOfEratosthenes big failed");
console.log("sieveOfEratosthenes passed");
}
export function testSqrtBig(){
//Test 1
let square: bigint = 25n;
let correctAnswer: bigint = 5n;
let answer = sqrtBig(square);
assert.ok((answer == correctAnswer), "sqrtBig test 1 failed");
//Test 2
square = 0n;
correctAnswer = 0n;
answer = sqrtBig(square);
assert.ok((answer == correctAnswer), "sqrtBig test 2 failed");
console.log("testSqrtBig passed");
}
export function testGetAllFib(){
//Test 1
let correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89];
let highestNumber = 100;
let answer = getAllFib(highestNumber);
assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 1 failed");
//Test 2
correctAnswer = [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]
highestNumber = 1000;
answer = getAllFib(highestNumber);
assert.ok(arrayEquals(answer, correctAnswer), "getAllFib number 2 failed");
//Test 3
let bigCorrectAnswer = [1n, 1n, 2n, 3n, 5n, 8n, 13n, 21n, 34n, 55n, 89n];
let bigHighestNumber = 100n;
let bigAnswer = getAllFibBig(bigHighestNumber);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getAllFibBig failed");
console.log("testGetAllFib passed");
}
export function testGetPrimes(){
//Test1
let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];
let topNum = 100;
let answer = getPrimes(topNum);
assert.ok(arrayEquals(answer, correctAnswer), "getPrimes number failed");
//Test 2
let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n];
let bigTopNum = 100n;
let bigAnswer = getPrimesBig(bigTopNum);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getPrimesBig failed");
console.log("getPrimes passed");
}
export function testGetNumPrimes(){
//Test1
let correctAnswer = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97];
let numPrimes = 25;
let answer = getNumPrimes(numPrimes);
assert.ok(arrayEquals(answer, correctAnswer), "getNumPrimes number failed");
//Test2
let bigCorrectAnswer = [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n];
let bigNumPrimes = 25n;
let bigAnswer = getNumPrimesBig(bigNumPrimes);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getNumPrimesBig failed");
console.log("getNumPrimes passed");
}
export function testIsPrime(){
//Test 1
let num: number = 2;
let correctAnswer: boolean = true;
let answer: boolean = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 1 failed");
//Test 2
num = 97;
correctAnswer = true;
answer = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 2 failed");
//Test 3
num = 1000;
correctAnswer = false;
answer = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 3 failed");
//Test 4
num = 1;
correctAnswer = false;
answer = isPrime(num);
assert.ok((answer == correctAnswer), "isPrime number 4 failed");
//Test 5
let bigNum: bigint = 2n;
correctAnswer = true;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 1 failed");
//Test 6
bigNum = 97n;
correctAnswer = true;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 2 failed");
//Test 7
bigNum = 1000n;
correctAnswer = false;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 3 failed");
//Test 8
bigNum = 1n;
correctAnswer = false;
answer = isPrimeBig(bigNum);
assert.ok((answer == correctAnswer), "isPrime big 4 failed");
console.log("isPrime passed");
}
export function testGetFactors(){
//Test 1
let correctAnswer = [2, 2, 5, 5];
let number = 100;
let answer = getFactors(number);
assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 1 failed");
//Test 2
correctAnswer = [2, 7, 7];
number = 98;
answer = getFactors(number);
assert.ok(arrayEquals(answer, correctAnswer), "getFactor number 2 failed");
//Test 3
let bigCorrectAnswer = [2n, 7n, 7n];
let bigNumber = 98n;
let bigAnswer = getFactorsBig(bigNumber);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getFactors BigInt failed");
console.log("getFactors passed");
}
export function testGetDivisors(){
//Test 1
let correctAnswer: number[] = [1, 2, 4, 5, 10, 20, 25, 50, 100];
let topNum: number = 100;
let answer: number[] = getDivisors(topNum);
assert.ok(arrayEquals(answer, correctAnswer), "getDivisors number failed");
//Test 2
let bigCorrectAnswer: bigint[] = [1n, 2n, 4n, 5n, 10n, 20n, 25n, 50n, 100n];
let bigTopNum: bigint = 100n;
let bigAnswer: bigint[] = getDivisorsBig(bigTopNum);
assert.ok(arrayEquals(bigAnswer, bigCorrectAnswer), "getDivisors BigInt failed");
console.log("getDivisors passed");
}
export function testGetFib(){
//Test 1
let correctAnswer: number = 144;
let number: number = 12;
let answer: number = getFib(number);
assert.ok((answer == correctAnswer), "getFib number 1 failed");
//Test 2
correctAnswer = 6765;
number = 20;
answer = getFib(number);
assert.ok((answer == correctAnswer), "getFib number 2 failed");
//Test 3
let bigCorrectAnswer: bigint = 144n;
let bigNumber: bigint = 12n;
let bigAnswer: bigint = getFibBig(bigNumber);
assert.ok((bigAnswer == bigCorrectAnswer), "getFib BigInt 1 failed");
//Test 4
bigCorrectAnswer = 6765n;
bigNumber = 20n;
bigAnswer = getFibBig(bigNumber);
assert.ok((bigAnswer == bigCorrectAnswer), "getFib BigInt 2 failed");
//Test 5
bigCorrectAnswer = 1070066266382758936764980584457396885083683896632151665013235203375314520604694040621889147582489792657804694888177591957484336466672569959512996030461262748092482186144069433051234774442750273781753087579391666192149259186759553966422837148943113074699503439547001985432609723067290192870526447243726117715821825548491120525013201478612965931381792235559657452039506137551467837543229119602129934048260706175397706847068202895486902666185435124521900369480641357447470911707619766945691070098024393439617474103736912503231365532164773697023167755051595173518460579954919410967778373229665796581646513903488154256310184224190259846088000110186255550245493937113651657039447629584714548523425950428582425306083544435428212611008992863795048006894330309773217834864543113205765659868456288616808718693835297350643986297640660000723562917905207051164077614812491885830945940566688339109350944456576357666151619317753792891661581327159616877487983821820492520348473874384736771934512787029218636250627816n;
bigNumber = 4782n;
bigAnswer = getFibBig(bigNumber);
assert.ok((bigAnswer == bigCorrectAnswer), "getFib BigInt 3 failed");
console.log("getFib passed");
}
export function testGCD(){
//Test 1
let num1: number = 2;
let num2: number = 3;
let correctAnswer: number = 1;
let answer: number = gcd(num1, num2);
assert.ok((answer == correctAnswer), "gcd number 1 failed");
//Test 2
num1 = 1000;
num2 = 575;
correctAnswer = 25;
answer = gcd(num1, num2);
assert.ok((answer == correctAnswer), "gcd number 2 failed");
//Test 3
num1 = 1000;
num2 = 1000;
correctAnswer = 1000;
answer = gcd(num1, num2);
assert.ok((answer == correctAnswer), "gcd number 3 failed");
//Test 4
let bigNum1: bigint = 2n;
let bigNum2: bigint = 3n;
let bigCorrectAnswer: bigint = 1n;
let bigAnswer: bigint = gcdBig(bigNum1, bigNum2);
assert.ok((bigAnswer == bigCorrectAnswer), "gcd BigInt 1 failed");
//Test 5
bigNum1 = 1000n;
bigNum2 = 575n;
bigCorrectAnswer = 25n;
bigAnswer = gcdBig(bigNum1, bigNum2);
assert.ok((bigAnswer == bigCorrectAnswer), "gcd BigInt 2 failed");
//Test 6
bigNum1 = 1000n;
bigNum2 = 1000n;
bigCorrectAnswer = 1000n;
bigAnswer = gcdBig(bigNum1, bigNum2);
assert.ok((bigAnswer == bigCorrectAnswer), "gcd BigInt 3 failed");
console.log("getGCD passed");
}
export function testFactorial(){
//Test 1
let num: number = 1;
let correctAnswer: number = 1;
let answer: number = factorial(num);
assert.ok((correctAnswer == answer), "factorial number 1 failed");
//Test 2
num = 10;
correctAnswer = 3628800;
answer = factorial(num);
assert.ok((correctAnswer == answer), "factorial number 2 failed");
//Test 3
num = -5;
correctAnswer = 1;
answer = factorial(num);
assert.ok((correctAnswer == answer), "factorial number 3 failed");
//Test 4
let numBig: bigint = 1n;
let correctAnswerBig: bigint = 1n;
let answerBig = factorialBig(numBig);
assert.ok((correctAnswerBig == answerBig), "factorialBig number 1 failed");
console.log("factorial passed");
}
export function testToBin(){
//Test 1
let num: number = 7;
let correctAnswer: string = "111";
let answer: string = toBin(num);
assert.ok((correctAnswer == answer), "toBin number 1 failed");
//Test 2
num = 0;
correctAnswer = "0";
answer = toBin(num);
assert.ok((correctAnswer == answer), "toBin number 2 failed");
//Test 3
num = 1000000;
correctAnswer = "11110100001001000000";
answer = toBin(num);
assert.ok((correctAnswer == answer), "toBin number 3 failed");
//Test 4
let numBig: bigint = 7n;
correctAnswer = "111";
answer = toBinBig(numBig);
assert.ok((correctAnswer == answer), "toBinBig number 1 failed");
//Test 5
numBig = 0n;
correctAnswer = "0";
answer = toBinBig(numBig);
assert.ok((correctAnswer == answer), "toBinBig number 2 failed");
//Test 6
numBig = 1000000n;
correctAnswer = "11110100001001000000";
answer = toBinBig(numBig);
assert.ok((correctAnswer == answer), "toBinBig number 3 failed");
console.log("toBin passed");
}

77
TestStringAlgorithms.ts Normal file
View File

@@ -0,0 +1,77 @@
//typescriptClasses/TestStringAlgorithms.ts
//Matthew Ellison
// Created: 07-13-21
//Modified: 07-13-21
//Tests for the string algorithms
/*
Copyright (C) 2021 Matthew Ellison
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
import assert = require("assert");
import { arrayEquals } from "./ArrayAlgorithms";
import { getPermutations, isPalindrome } from "./StringAlgorithms";
export function testGetPermutations(){
//Test 1
let permString: string = "012";
let correctAnswer: string[] = ["012", "021", "102", "120", "201", "210"];
let answer: string[] = getPermutations(permString);
assert.ok(arrayEquals(answer, correctAnswer), "getPermutations failed");
console.log("getPermutations passed");
}
export function testIsPalindrome(){
//Test 1
let str: string = "101";
let correctAnswer: boolean = true;
let answer: boolean = isPalindrome(str);
assert.ok((answer == correctAnswer), "isPalindrome number 1 failed");
//Test 2
str = "100";
correctAnswer = false;
answer = isPalindrome(str);
assert.ok((answer == correctAnswer), "isPalindrome number 2 failed");
//Test 3
str = "";
correctAnswer = true;
answer = isPalindrome(str);
assert.ok((answer == correctAnswer), "isPalindrome number 3 failed");
console.log("isPalindrome passed");
}
export function testFindNumOccurrences(){
//Test 1
let str: string = "101";
let correctAnswer: boolean = true;
let answer = isPalindrome(str);
assert.ok((answer == correctAnswer), "findNumOccurrences 1 failed");
//Test 2
str = "100";
correctAnswer = false;
answer = isPalindrome(str);
assert.ok((answer == correctAnswer), "findNumOccurrences 2 failed");
//Test 3
str = "";
correctAnswer = true;
answer = isPalindrome(str);
assert.ok((answer == correctAnswer), "findNumOccurrences 3 failed");
console.log("findNumOccurrences passed");
}