gauss

Author: PeterLuschny

docs/src/index.md

@@ -103,7 +103,7 @@ FallingFactorial
 GammaHyp
 ```
 ```@docs
-GaußFactorial
+GaussFactorial
 ```
 ```@docs
 HilbertHotel
@@ -178,7 +178,7 @@ ModuleFibonacci
 ModuleFigurativeNumbers
 ```
 ```@docs
-ModuleGaussFactorial
+ModuleGaussFactorials
 ```
 ```@docs
 ModuleGeneralizedBinomial
@@ -823,6 +823,9 @@ T001497
 L001710
 ```
 ```@docs
+V001783
+```
+```@docs
 V001813
 ```
 ```@docs
@@ -1381,6 +1384,9 @@ T053121
 V054248
 ```
 ```@docs
+V055634
+```
+```@docs
 T055883
 ```
 ```@docs
@@ -1432,6 +1438,9 @@ L065855
 T066325
 ```
 ```@docs
+V066570
+```
+```@docs
 V067998
 ```
 ```@docs
@@ -1615,6 +1624,12 @@ V123753
 V124320
 ```
 ```@docs
+V124441
+```
+```@docs
+V124442
+```
+```@docs
 T132062
 ```
 ```@docs
@@ -1741,6 +1756,9 @@ L214551
 T216916
 ```
 ```@docs
+V216919
+```
+```@docs
 T217537
 ```
 ```@docs
@@ -1759,6 +1777,15 @@ I225498
 L225498
 ```
 ```@docs
+V232980
+```
+```@docs
+V232981
+```
+```@docs
+V232982
+```
+```@docs
 L242660
 ```
 ```@docs

docs/src/modules.md

@@ -130,11 +130,11 @@ Applying Deléham's Δ-operation often gives an additional first column or an ad
 
 * PolygonalNumber, PyramidalNumber, V014107, V095794, V067998, V080956, V001477, V000217, V000290, V000326, V000384, V000566, V000567, V001106, V001107, V005564, V058373, V254749, V000292, V000330, V002411, V002412, V002413, V002414, V007584, V007585
 
-   🔶  [GaussFactorial](https://github.com/OpenLibMathSeq/IntegerSequences.jl/blob/master/src/GaussFactorial.jl)
+   🔶  [GaussFactorials](https://github.com/OpenLibMathSeq/IntegerSequences.jl/blob/master/src/GaussFactorials.jl)
 
 The Gauß factorial is ``∏_{1 ≤ j ≤ N, j ⊥ n} j``, the product of the positive integers which are ``≤ N`` and are prime to ``n``.
 
-* GaußFactorial, I193338, F193338, L193338, V193338, I193339, F193339, L193339, V193339
+* GaussFactorial, I193338, F193338, L193338, V193338, I193339, F193339, L193339, V193339, V216919, V001783, V055634, V232980, V232981, V232982, V124441, V124442, V066570
 
    🔶  [GeneralizedBinomial](https://github.com/OpenLibMathSeq/IntegerSequences.jl/blob/master/src/GeneralizedBinomial.jl)
 

src/GaussFactorial.jl src/GaussFactorials.jlsrc/GaussFactorial.jl renamed to src/GaussFactorials.jl

@@ -3,41 +3,93 @@
 
 (@__DIR__) ∉ LOAD_PATH && push!(LOAD_PATH, (@__DIR__))
 
-module GaussFactorial
+module GaussFactorials
 
 using Nemo, IterTools
 using RecordSearch, NumberTheory, Products
 
-export ModuleGaussFactorial, GaußFactorial
+export ModuleGaussFactorials, GaussFactorial
+export V216919, V001783, V055634, V232980, V232981, V232982, V124441, V124442, V066570
 export I193338, F193338, L193338, V193338
 export I193339, F193339, L193339, V193339
 
 """
 The Gauß factorial is ``∏_{1 ≤ j ≤ N, j ⊥ n} j``, the product of the positive integers which are ``≤ N`` and are prime to ``n``.
 
-* GaußFactorial, I193338, F193338, L193338, V193338, I193339, F193339, L193339, V193339
+* GaussFactorial, I193338, F193338, L193338, V193338, I193339, F193339, L193339, V193339, V216919, V001783, V055634, V232980, V232981, V232982, V124441, V124442, V066570
 """
-const ModuleGaussFactorial = ""
-
-# A216919
+const ModuleGaussFactorials = ""
 
 """
 Return ``∏_{1 ≤ j ≤ N, j ⊥ n} j``, the product of the positive integers which are ``≤ N`` and are prime to ``n``.
 """
-GaußFactorial(n) = prod([j for j in 1:Int(n) if ⊥(j, n)])
+GaussFactorial(N, n) = ∏([j for j in 1:Int(N) if ⊥(j, n)])
+
+"""
+Return ``∏_{1 ≤ j ≤ n, j ⊥ n} j``, the product of the positive integers which are ``≤ n`` and are prime to ``n``.
+"""
+GaussFactorial(n) = GaussFactorial(n, n)
+
+# V000142(n) = n! = GaussFactorial(n, 1).
+# V001147(n) = GaussFactorial(2*n, 2), double factorial of odd numbers.
+
+"""
+Return GaussFactorial(N, n).
+"""
+V216919(N, n) = GaussFactorial(N, n)
+
+"""
+Return ``∏_{1 ≤ j ≤ n, j ⊥ n} j``, the product of the positive integers which are ``≤ N`` and are prime to ``n``, a.k.a. the phi-torial of n.
+"""
+V001783(n) = GaussFactorial(n, n)
+
+""" 
+Return the 2-adic factorial of n.
+"""
+V055634(n) = GaussFactorial(n, 2)*(-1)^n
+
+""" 
+Return GaussFactorial(n, 3).
+"""
+V232980(n) = GaussFactorial(n, 3)
+
+""" 
+Return GaussFactorial(n, 5).
+"""
+V232981(n) = GaussFactorial(n, 5)
+
+""" 
+Return GaussFactorial(n, 6).
+"""
+V232982(n) = GaussFactorial(n, 6)
+
+"""
+Return GaussFactorial(div(n, 2), n).
+"""
+V124441(n) = GaussFactorial(div(n, 2), n)
+
+"""
+Return GaussFactorial(n, n)/GaussFactorial(div(n, 2), n).
+"""
+V124442(n) = div(GaussFactorial(n, n), GaussFactorial(div(n, 2), n))
+
+"""
+Return GaussFactorial(n, 1)/GaussFactorial(n, n).
+"""
+V066570(n) = div(GaussFactorial(n, 1), GaussFactorial(n, n))
 
 # -----------------------------------------------------------------
 # Indices!
 
 """
 Iterate over the indices of the first ``n`` record values of the Gauß factorial.
 """
-I193339(n) = Records(GaußFactorial, n, true, true)
+I193339(n) = Records(GaussFactorial, n, true, true)
 
 """
 Iterate over indices of the record values of the Gauß factorial which do not exceed ``n`` (``1 ≤ i ≤ n``).
 """
-F193339(n) = Records(GaußFactorial, n, false, true)
+F193339(n) = Records(GaussFactorial, n, false, true)
 
 """
 Return the indices of the first ``n`` record values of the Gauß factorial as an array.
@@ -55,12 +107,12 @@ V193339(n) = nth(I193339(n), n)
 """
 Iterate over the first ``n`` record values of the Gauß factorial (``1 ≤ r``).
 """
-I193338(n) = Records(GaußFactorial, n, true, false)
+I193338(n) = Records(GaussFactorial, n, true, false)
 
 """
 Iterate over the record values of the Gauß factorial which do not exceed ``n`` (``1 ≤ i ≤ n``).
 """
-F193338(n) = Records(GaußFactorial, n, false, false)
+F193338(n) = Records(GaussFactorial, n, false, false)
 
 """
 Return the first ``n`` record values of the Gauß factorial as an array.
@@ -74,14 +126,25 @@ V193338(n) = nth(I193338(n), n)
 
 #START-TEST-########################################################
 
-using Test
+using Test, SeqTests
 
 function test()
+
+    @testset "GaussFactorial" begin
+
+        #@test 
+        if is_oeis_installed()
+
+            V = [V001783, V124441, V124442, V066570]
+            for v in V SeqTest(v, 'V', 1) end
+            
+            W = [V055634, V232980, V232981, V232982]
+            for w in W SeqTest(w, 'V', 0) end
+        end
+    end
 end
 
 function demo()
-    # 1, 3, 4, 5, 7, 9, 11, 13, 17, 19, ...
-
     println("\n Iterate over the indices of the first 10 record values of the Gauß factorial.")
     for r in I193339(10) print(r, ", ") end; println("...")
 
@@ -122,26 +185,26 @@ end # module
 
 #=
 Iterate over the indices of the first 10 record values ofthe Gauß factorial.
-0, 0, 3, 4, 5, 7, 9, 11, 13, 17, ...
+1, 3, 4, 5, 7, 9, 11, 13, 17, ...
 
 Iterate over indices of the record values of the Gauß factorial which do not exceed 10.
-0, 0, 3, 4, 5, 7, 9, ...
+1, 3, 4, 5, 7, 9, ...
 
 Return the indices of the first 10 record values of the Gauß factorial as an array.
-Nemo.fmpz[0, 0, 3, 4, 5, 7, 9, 11, 13, 17]
+Nemo.fmpz[1, 3, 4, 5, 7, 9, 11, 13, 17]
 
 Return the index of the 9-th record value of the Gauß factorial.
 9 -> 13
 
 Iterate over the first 10 record values of the Gauß factorial.
-0, 1, 2, 3, 24, 720, 2240, 3628800, 479001600, 20922789888000, ...
+1, 2, 3, 24, 720, 2240, 3628800, 479001600, 20922789888000, ...
 
 Iterate over the record values of Gauß factorial which do
 not exceed 10.
-0, 1, 2, 3, 24, 720, 2240, ...
+1, 2, 3, 24, 720, 2240, ...
 
 Return the first 10 record values of the Gauß factorial as an array.
-Nemo.fmpz[0, 1, 2, 3, 24, 720, 2240, 3628800, 479001600, 20922789888000]
+Nemo.fmpz[1, 2, 3, 24, 720, 2240, 3628800, 479001600, 20922789888000]
 
 Return the (value of the) 9-th record of the Gauß factorial.
 9 -> 479001600

src/HighlyAbundant.jl

@@ -118,25 +118,25 @@ end # module
 
 #=
 Iterate over the first 20 highly abundant numbers.
-0, 1, 2, 3, 4, 6, 8, 10, 12, 16, 18, 20, 24, 30, 36, 42, 48, 60, 72, 84, ...
+1, 2, 3, 4, 6, 8, 10, 12, 16, 18, 20, 24, 30, 36, 42, 48, 60, 72, 84, ...
 
 Return the first 20 highly abundant numbers as an array.
-Nemo.fmpz[0, 1, 2, 3, 4, 6, 8, 10, 12, 16, 18, 20, 24, 30, 36, 42, 48, 60, 72, 84]
+Nemo.fmpz[1, 2, 3, 4, 6, 8, 10, 12, 16, 18, 20, 24, 30, 36, 42, 48, 60, 72, 84]
 
 Iterate over the highly abundant numbers which do not exceed 20.
-0, 1, 2, 3, 4, 6, 8, 10, 12, 16, 18, 20, ...
+1, 2, 3, 4, 6, 8, 10, 12, 16, 18, 20, ...
 
 Return the 9-th highly abundant number.
 9 -> 12
 
 Iterate over the first 20 record values of sigma.
-0, 1, 3, 4, 7, 12, 15, 18, 28, 31, 39, 42, 60, 72, 91, 96, 124, 168, 195, 224, ...
+1, 3, 4, 7, 12, 15, 18, 28, 31, 39, 42, 60, 72, 91, 96, 124, 168, 195, 224, ...
 
 Return the first 20 record values of sigma as an array.
-Nemo.fmpz[0, 1, 3, 4, 7, 12, 15, 18, 28, 31, 39, 42, 60, 72, 91, 96, 124, 168, 195, 224]
+Nemo.fmpz[1, 3, 4, 7, 12, 15, 18, 28, 31, 39, 42, 60, 72, 91, 96, 124, 168, 195, 224]
 
 Iterate over the record values of sigma the indices of which do not exceed 20.
-0, 1, 3, 4, 7, 12, 15, 18, 28, 31, 39, 42, ...
+1, 3, 4, 7, 12, 15, 18, 28, 31, 39, 42, ...
 
 Return the 9-th record of sigma.
 9 -> 28