Simplify docs to hide the copyright

core/math/big/api.odin

@@ -2,12 +2,10 @@
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
 
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
-
 	This file collects public proc maps and their aliases.
 */
+
+
 package math_big
 /*
 

core/math/big/common.odin

@@ -1,11 +1,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/doc.odin

@@ -0,0 +1,28 @@
+/*
+A BigInt implementation in Odin.
+For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
+The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
+
+==========================    Low-level routines    ==========================
+
+IMPORTANT: `internal_*` procedures make certain assumptions about their input.
+
+The public functions that call them are expected to satisfy their sanity check requirements.
+This allows `internal_*` call `internal_*` without paying this overhead multiple times.
+
+Where errors can occur, they are of course still checked and returned as appropriate.
+
+When importing `math:core/big` to implement an involved algorithm of your own, you are welcome
+to use these procedures instead of their public counterparts.
+
+Most inputs and outputs are expected to be passed an initialized `Int`, for example.
+Exceptions include `quotient` and `remainder`, which are allowed to be `nil` when the calling code doesn't need them.
+
+Check the comments above each `internal_*` implementation to see what constraints it expects to have met.
+
+We pass the custom allocator to procedures by default using the pattern `context.allocator = allocator`.
+This way we don't have to add `, allocator` at the end of each call.
+
+TODO: Handle +/- Infinity and NaN.
+*/
+package math_big

core/math/big/helpers.odin

@@ -1,11 +1,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	An arbitrary precision mathematics implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/internal.odin

@@ -2,33 +2,9 @@
 /*
 	Copyright 2021 Jeroen van Rijn <nom@duclavier.com>.
 	Made available under Odin's BSD-3 license.
-
-	A BigInt implementation in Odin.
-	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
-	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
-
-	==========================    Low-level routines    ==========================
-
-	IMPORTANT: `internal_*` procedures make certain assumptions about their input.
-
-	The public functions that call them are expected to satisfy their sanity check requirements.
-	This allows `internal_*` call `internal_*` without paying this overhead multiple times.
-
-	Where errors can occur, they are of course still checked and returned as appropriate.
-
-	When importing `math:core/big` to implement an involved algorithm of your own, you are welcome
-	to use these procedures instead of their public counterparts.
-
-	Most inputs and outputs are expected to be passed an initialized `Int`, for example.
-	Exceptions include `quotient` and `remainder`, which are allowed to be `nil` when the calling code doesn't need them.
-
-	Check the comments above each `internal_*` implementation to see what constraints it expects to have met.
-
-	We pass the custom allocator to procedures by default using the pattern `context.allocator = allocator`.
-	This way we don't have to add `, allocator` at the end of each call.
-
-	TODO: Handle +/- Infinity and NaN.
 */
+
+
 package math_big
 
 import "core:mem"

core/math/big/logical.odin

@@ -8,6 +8,8 @@
 
 	This file contains logical operations like `and`, `or` and `xor`.
 */
+
+
 package math_big
 
 /*

core/math/big/prime.odin

@@ -8,6 +8,8 @@
 
 	This file contains prime finding operations.
 */
+
+
 package math_big
 
 import rnd "core:math/rand"

core/math/big/private.odin

@@ -15,6 +15,8 @@
 
 	These aren't exported for the same reasons.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/public.odin

@@ -8,6 +8,8 @@
 
 	This file contains basic arithmetic operations like `add`, `sub`, `mul`, `div`, ...
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/radix.odin

@@ -12,6 +12,8 @@
 		- Use Barrett reduction for non-powers-of-two.
 		- Also look at extracting and splatting several digits at once.
 */
+
+
 package math_big
 
 import "core:intrinsics"

core/math/big/tune.odin

@@ -7,6 +7,8 @@
 	For the theoretical underpinnings, see Knuth's The Art of Computer Programming, Volume 2, section 4.3.
 	The code started out as an idiomatic source port of libTomMath, which is in the public domain, with thanks.
 */
+
+
 package math_big
 
 import "core:time"