Stewart's Theorem

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+ """
+ Loop through every character in the data and add to two sums.
+
+ >>> fletcher16('hello world')
+ 6752
+ >>> fletcher16('onethousandfourhundredthirtyfour')
+ 28347
+ >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+ 5655
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ for character in data:
+ sum1 = (sum1 + character) % 255
+ sum2 = (sum1 + sum2) % 255
+ return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

hashes/fletcher32.py

@@ -0,0 +1,40 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher32(text: str) -> int:
+ """
+ Turns the data into a list, and then loops them in pairs of two and adds to sums
+
+ >>> fletcher32('Apple')
+ 705355030
+ >>> fletcher32('ABCDEFGHI')
+ 3220837722
+ >>> fletcher32("abcd")
+ 690407108
+ """
+ data = bytes(text, "ascii")
+ sum1 = 0
+ sum2 = 0
+ data_list = list(data)
+ if len(data_list) % 2 == 1:
+ data_list.append(0)
+ for idx in range(len(data_list) // 2):
+ v = (data_list[idx * 2 + 1] << 8) + data_list[idx * 2]
+ sum1 = (sum1 + v) % 65535
+ sum2 = (sum1 + sum2) % 65535
+ return (sum2 << 16) | sum1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()

maths/stewart.py

@@ -0,0 +1,42 @@
+"""
+In geometry, Stewart's theorem yields a relation between the
+lengths of the sides and the length of a cevian in a triangle.
+Its name is in honour of the Scottish mathematician Matthew
+Stewart, who published the theorem in 1746.[1]
+
+Source: https://en.wikipedia.org/wiki/Stewart%27s_theorem
+"""
+
+
+def stewart(a: float, b: float, c: float, n: float, m: float) -> float:
+ """
+ Given the side lengths of the triangle (a,b,c), where the cevian intersects
+ the side with side length a and splits it into segments with lengths n and m,
+ this formula finds the length of the cevian.
+
+ >>> stewart(1,1,1,0.5,0.5)
+ 0.8660254037844386
+ >>> stewart(1,2,3,4,5)
+ Traceback (most recent call last):
+ ...
+ ValueError: This triangle violates the triangle inequality
+ >>> stewart(1,1,1,1,1)
+ Traceback (most recent call last):
+ ...
+ ValueError: n+m must equal a
+ >>> stewart(3,2,4,1.7,1.3)
+ 2.9308701779505686
+ """
+ if a + b <= c or b + c <= a or a + c <= b:
+ raise ValueError("This triangle violates the triangle inequality")
+ if n + m != a:
+ raise ValueError("n+m must equal a")
+ if a <= 0 or b <= 0 or c <= 0 or n < 0 or m < 0:
+ raise ValueError("The side lengths of a triangle have to be positive")
+ return ((b**2 * m + c**2 * n - m * a * n) / a) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()