add norm (#18)

* add norm

* norm for inf fill arrays

* Add special vcat

* v0.3.1

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "InfiniteArrays"
 uuid = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
-version = "0.3"
+version = "0.3.1"
 
 [deps]
 DSP = "717857b8-e6f2-59f4-9121-6e50c889abd2"

src/InfiniteArrays.jl

@@ -22,27 +22,31 @@ import Base: *, +, -, /, \, ==, isinf, isfinite, sign, angle, show, isless,
          AbstractArray, AbstractVector, Array, Vector, Matrix,
          axes, (:), _sub2ind_recurse, broadcast, promote_eltypeof,
          diff, cumsum, show_delim_array, show_circular, Int,
-         similar, _unsafe_getindex, string, zeros, fill, permutedims
+         similar, _unsafe_getindex, string, zeros, fill, permutedims,
+         cat_similar, vcat
 
 using Base.Broadcast
 import Base.Broadcast: BroadcastStyle, AbstractArrayStyle, Broadcasted, broadcasted,
                         @nexprs, @ncall, combine_eltypes, DefaultArrayStyle, instantiate
 
 import LinearAlgebra: BlasInt, BlasFloat, norm, diag, diagm, ishermitian, issymmetric,
-                             det, logdet, istriu, istril, adjoint, tr, AbstractTriangular
+                             det, logdet, istriu, istril, adjoint, tr, AbstractTriangular,
+                             norm2, norm1, normp
 
 import Statistics: mean, median
 
 import FillArrays: AbstractFill, getindex_value
 import LazyArrays: LazyArrayStyle, AbstractBandedLayout, MemoryLayout, LazyLayout,
-                    ZerosLayout, @lazymul, AbstractArrayApplyStyle
+                    ZerosLayout, @lazymul, AbstractArrayApplyStyle, CachedArray, CachedVector
 
 import DSP: conv
 
 export ∞, Hcat, Vcat, Zeros, Ones, Fill, Eye, BroadcastArray, cache
 
 
 
+
+
 include("Infinity.jl")
 include("infrange.jl")
 include("infarrays.jl")
@@ -80,8 +84,36 @@ length(::Zeros{<:Any,2,Tuple{OneToInf{Int},OneToInf{Int}}}) = ∞
 length(::Zeros{<:Any,2,<:Tuple{OneToInf{Int},<:Any}}) = ∞
 length(::Zeros{<:Any,2,<:Tuple{<:Any,OneToInf{Int}}}) = ∞
 
-vcat(a::Number, b::AbstractFill{<:Any,1,<:Tuple{<:OneToInf}}) = Vcat(a, b)
-vcat(a::AbstractVector, b::AbstractFill{<:Any,1,<:Tuple{<:OneToInf}}) = Vcat(a, b)
+for op in (:norm2, :norm1)
+   @eval $op(a::Zeros{T,N,NTuple{N,OneToInf{Int}}}) where {T,N} = norm(getindex_value(a))
+end
+
+normp(a::Zeros{T,N,NTuple{N,OneToInf{Int}}}, p) where {T,N} = norm(getindex_value(a))
+
+for N=1:3
+   for op in (:norm2, :norm1)
+      @eval function $op(a::AbstractFill{T,$N,NTuple{$N,OneToInf{Int}}}) where {T,N}
+         z = norm(getindex_value(a))
+         iszero(z) && return z
+         typeof(z)(Inf)
+      end
+   end
+   @eval function normp(a::AbstractFill{T,$N,NTuple{$N,OneToInf{Int}}}, p) where {T,N }
+      z = norm(getindex_value(a))
+      iszero(z) && return z
+      typeof(z)(Inf)
+   end
+end
+
+for Typ in (:Number, :AbstractVector)
+   @eval begin
+      vcat(a::$Typ, b::AbstractFill{<:Any,1,<:Tuple{<:OneToInf}}) = Vcat(a, b)      
+      vcat(a::$Typ, c::CachedVector{<:Any,<:Any,<:AbstractFill{<:Any,1,<:Tuple{<:OneToInf}}}) = 
+         CachedArray(vcat(a, view(c.data,1:c.datasize[1])), c.array)
+   end
+end
+
+# cat_similar(A, T, ::Tuple{Infinity}) = zeros(T, ∞)
 
 ##
 # Temporary hacks for base support
@@ -96,4 +128,6 @@ OneTo{T}(::OneToInf) where T<:Integer = OneToInf{T}()
 Int(::Infinity) = ∞
 
 
+
+
 end # module

test/runtests.jl

@@ -511,6 +511,13 @@ end
 
         @test_throws ArgumentError maximum(exp.(1:∞))
     end
+
+    @testset "special vcat" begin
+        @test [1; Zeros(∞)][1:10] == [1; zeros(9)]
+        @test [[1,2,3]; Zeros(∞)][1:10] == [1;2;3;zeros(7)]
+        @test [1; zeros(∞)] isa CachedArray
+        @test [[1,2,3]; zeros(∞)] isa CachedArray
+    end
 end
 
 @testset "broadcasting" begin
@@ -637,4 +644,12 @@ end
 @testset "permutedims" begin
     @test permutedims(1:∞) isa Transpose
     @test permutedims(1:∞)[1,1:10] == (1:10)
+end
+
+@testset "norm" begin
+    for p in (-Inf, 0, 0.1, 1, 2, 3, Inf)
+        @test norm(Zeros(∞), p) == 0.0
+        @test norm(Fill(5),p) ≈ norm(Array(Fill(5)),p) # tests tuple bug
+        @test norm(Zeros{Float64}(),p) == 0.0 # tests tuple bug
+    end
 end