Merge pull request #17 from FugroRoames/rename-affine-map-05

Rename affine map

Author: c42f

src/CoordinateTransformations.jl

@@ -24,8 +24,8 @@ export SphericalFromCartesian, CartesianFromSpherical,
        CylindricalFromSpherical, SphericalFromCylindrical
 
 # Common transformations
-export AbstractAffineTransformation, AbstractLinearTransformation, AbstractTranslation
-export AffineTransformation, LinearTransformation, Translation, transformation_matrix, translation_vector, translation_vector_reverse
+export AbstractAffineMap
+export AffineMap, LinearMap, Translation
 
 include("core.jl")
 include("coordinatesystems.jl")

src/affine.jl

@@ -1,14 +1,14 @@
-abstract AbstractAffineTransformation <: Transformation
+abstract AbstractAffineMap <: Transformation
 
 """
-    Translation(v) <: AbstractAffineTransformation
+    Translation(v) <: AbstractAffineMap
     Translation(dx, dy)       (2D)
     Translation(dx, dy, dz)   (3D)
 
 Construct the `Translation` transformation for translating Cartesian points by
 an offset `v = (dx, dy, ...)`
 """
-immutable Translation{V <: AbstractVector} <: AbstractAffineTransformation
+immutable Translation{V <: AbstractVector} <: AbstractAffineMap
     v::V
 end
 Translation(x::Tuple) = Translation(SVector(x))
@@ -35,72 +35,72 @@ end
 
 
 """
-    LinearTransformation <: AbstractAffineTransformation
-    LinearTransformation(M)
+    LinearMap <: AbstractAffineMap
+    LinearMap(M)
 
-A general linear transformation, constructed using `LinearTransformation(M)`
+A general linear transformation, constructed using `LinearMap(M)`
 for any `AbstractMatrix` `M`.
 """
-immutable LinearTransformation{M <: AbstractMatrix} <: AbstractAffineTransformation
+immutable LinearMap{M <: AbstractMatrix} <: AbstractAffineMap
     m::M
 end
-Base.show(io::IO, trans::LinearTransformation)   = print(io, "LinearTransformation($(trans.M))") # TODO make this output more petite
+Base.show(io::IO, trans::LinearMap)   = print(io, "LinearMap($(trans.M))") # TODO make this output more petite
 
-function (trans::LinearTransformation{M}){M}(x)
+function (trans::LinearMap{M}){M}(x)
     trans.m * x
 end
 
-Base.inv(trans::LinearTransformation) = LinearTransformation(inv(trans.m))
+Base.inv(trans::LinearMap) = LinearMap(inv(trans.m))
 
-compose(t1::LinearTransformation, t2::LinearTransformation) = LinearTransformation(t1.m * t2.m)
+compose(t1::LinearMap, t2::LinearMap) = LinearMap(t1.m * t2.m)
 
-function Base.isapprox(t1::LinearTransformation, t2::LinearTransformation; kwargs...)
+function Base.isapprox(t1::LinearMap, t2::LinearMap; kwargs...)
     isapprox(t1.m, t2.m; kwargs...)
 end
 
-function Base.isapprox(t1::LinearTransformation, t2::Translation; kwargs...)
+function Base.isapprox(t1::LinearMap, t2::Translation; kwargs...)
     isapprox(vecnorm(t1.m), 0; kwargs...) &&
         isapprox(vecnorm(t2.v),0; kwargs...)
 end
 
-function Base.isapprox(t1::Translation, t2::LinearTransformation; kwargs...)
+function Base.isapprox(t1::Translation, t2::LinearMap; kwargs...)
     isapprox(vecnorm(t1.v), 0; kwargs...) &&
         isapprox(vecnorm(t2.m),0; kwargs...)
 end
 
-function Base.:(==)(t1::LinearTransformation, t2::Translation)
+function Base.:(==)(t1::LinearMap, t2::Translation)
     vecnorm(t1.m) == 0 &&
         0 == vecnorm(t2.v)
 end
 
-function Base.:(==)(t1::Translation, t2::LinearTransformation)
+function Base.:(==)(t1::Translation, t2::LinearMap)
     vecnorm(t1.v) == 0 &&
         vecnorm(t2.m) == 0
 end
 
-transform_deriv(trans::LinearTransformation, x) = trans.m
+transform_deriv(trans::LinearMap, x) = trans.m
 # TODO transform_deriv_params
 
 """
-    AffineTransformation <: AbstractAffineTransformation
+    AffineMap <: AbstractAffineMap
 
 A concrete affine transformation.  To construct the mapping `x -> M*x + v`, use
 
-    AffineTransformation(M, v)
+    AffineMap(M, v)
 
 where `M` is a matrix and `v` a vector.  An arbitrary `Transformation` may be
 converted into an affine approximation by linearizing about a point `x` using
 
-    AffineTransformation(trans, [x])
+    AffineMap(trans, [x])
 
 For transformations which are already affine, `x` may be omitted.
 """
-immutable AffineTransformation{M <: AbstractMatrix, V <: AbstractVector} <: AbstractAffineTransformation
+immutable AffineMap{M <: AbstractMatrix, V <: AbstractVector} <: AbstractAffineMap
     m::M
     v::V
 end
 
-function (trans::AffineTransformation{M,V}){M,V}(x)
+function (trans::AffineMap{M,V}){M,V}(x)
     trans.m * x + trans.v
 end
 
@@ -109,98 +109,98 @@ end
 # translation won't fix things, because then we'd have `Tx*(x-x0)` which
 # also can incur large cancellation error in `x-x0`.
 """
-    AffineTransformation(trans::Transformation, x0)
+    AffineMap(trans::Transformation, x0)
 
 Create an Affine transformation corresponding to the differential transformation
 of `x0 + dx` according to `trans`, i.e. the Affine transformation that is
 locally most accurate in the vicinity of `x0`.
 """
-function AffineTransformation(trans::Transformation, x0)
+function AffineMap(trans::Transformation, x0)
     dT = transform_deriv(trans, x0)
     Tx = trans(x0)
-    AffineTransformation(dT, Tx - dT*x0)
+    AffineMap(dT, Tx - dT*x0)
 end
 
-Base.show(io::IO, trans::AffineTransformation) = print(io, "AffineTransformation($(trans.M), $(trans.v))") # TODO make this output more petite
+Base.show(io::IO, trans::AffineMap) = print(io, "AffineMap($(trans.M), $(trans.v))") # TODO make this output more petite
 
-function compose(t1::Translation, t2::LinearTransformation)
-    AffineTransformation(t2.m, t1.v)
+function compose(t1::Translation, t2::LinearMap)
+    AffineMap(t2.m, t1.v)
 end
 
-function compose(t1::LinearTransformation, t2::Translation)
-    AffineTransformation(t1.m, t1.m * t2.v)
+function compose(t1::LinearMap, t2::Translation)
+    AffineMap(t1.m, t1.m * t2.v)
 end
 
-function compose(t1::AffineTransformation, t2::AffineTransformation)
-    AffineTransformation(t1.m * t2.m, t1.v + t1.m * t2.v)
+function compose(t1::AffineMap, t2::AffineMap)
+    AffineMap(t1.m * t2.m, t1.v + t1.m * t2.v)
 end
 
-function compose(t1::AffineTransformation, t2::LinearTransformation)
-    AffineTransformation(t1.m * t2.m, t1.v)
+function compose(t1::AffineMap, t2::LinearMap)
+    AffineMap(t1.m * t2.m, t1.v)
 end
 
-function compose(t1::LinearTransformation, t2::AffineTransformation)
-    AffineTransformation(t1.m * t2.m, t1.m * t2.v)
+function compose(t1::LinearMap, t2::AffineMap)
+    AffineMap(t1.m * t2.m, t1.m * t2.v)
 end
 
-function compose(t1::AffineTransformation, t2::Translation)
-    AffineTransformation(t1.m, t1.v + t1.m * t2.v)
+function compose(t1::AffineMap, t2::Translation)
+    AffineMap(t1.m, t1.v + t1.m * t2.v)
 end
 
-function compose(t1::Translation, t2::AffineTransformation)
-    AffineTransformation(t2.m, t1.v + t2.v)
+function compose(t1::Translation, t2::AffineMap)
+    AffineMap(t2.m, t1.v + t2.v)
 end
 
-function Base.inv(trans::AffineTransformation)
+function Base.inv(trans::AffineMap)
     m_inv = inv(trans.m)
-    AffineTransformation(m_inv, m_inv * (-trans.v))
+    AffineMap(m_inv, m_inv * (-trans.v))
 end
 
-function Base.isapprox(t1::AffineTransformation, t2::AffineTransformation; kwargs...)
+function Base.isapprox(t1::AffineMap, t2::AffineMap; kwargs...)
     isapprox(t1.m, t2.m; kwargs...) &&
         isapprox(t1.v, t2.v; kwargs...)
 end
 
-function Base.isapprox(t1::AffineTransformation, t2::Translation; kwargs...)
+function Base.isapprox(t1::AffineMap, t2::Translation; kwargs...)
     isapprox(vecnorm(t1.m), 0; kwargs...) &&
         isapprox(t1.v, t2.v; kwargs...)
 end
 
-function Base.isapprox(t1::Translation, t2::AffineTransformation; kwargs...)
+function Base.isapprox(t1::Translation, t2::AffineMap; kwargs...)
     isapprox(vecnorm(t2.m), 0; kwargs...) &&
         isapprox(t1.v, t2.v; kwargs...)
 end
 
-function Base.isapprox(t1::AffineTransformation, t2::LinearTransformation; kwargs...)
+function Base.isapprox(t1::AffineMap, t2::LinearMap; kwargs...)
     isapprox(t1.m, t2.m; kwargs...) &&
         isapprox(vecnorm(t1.v), 0; kwargs...)
 end
 
-function Base.isapprox(t1::LinearTransformation, t2::AffineTransformation; kwargs...)
+function Base.isapprox(t1::LinearMap, t2::AffineMap; kwargs...)
     isapprox(t1.m, t2.m; kwargs...) &&
         isapprox(0, vecnorm(t2.v); kwargs...)
 end
 
 
-function Base.:(==)(t1::AffineTransformation, t2::Translation)
+function Base.:(==)(t1::AffineMap, t2::Translation)
     vecnorm(t1.m) == 0 &&
         t1.v == t2.v
 end
 
-function Base.:(==)(t1::Translation, t2::AffineTransformation)
+function Base.:(==)(t1::Translation, t2::AffineMap)
     vecnorm(t2.m) == 0 &&
         t1.v == t2.v
 end
 
-function Base.:(==)(t1::AffineTransformation, t2::LinearTransformation)
+function Base.:(==)(t1::AffineMap, t2::LinearMap)
     t1.m == t2.m &&
         vecnorm(t1.v) == 0
 end
 
-function Base.:(==)(t1::LinearTransformation, t2::AffineTransformation)
+function Base.:(==)(t1::LinearMap, t2::AffineMap)
     t1.m == t2.m &&
         0 == vecnorm(t2.v)
 end
 
-transform_deriv(trans::AffineTransformation, x) = trans.m
+transform_deriv(trans::AffineMap, x) = trans.m
 # TODO transform_deriv_params

test/affine.jl

@@ -6,23 +6,23 @@ CoordinateTransformations.transform_deriv(::SquareMe, x0) = diagm(2*x0)
 
 
 @testset "Common Transformations" begin
-    @testset "AffineTransformation" begin
+    @testset "AffineMap" begin
         @testset "Simple" begin
             M = [1 2; 3 4]
             v = [-1, 1]
             x = [1,0]
             y = [0.0,1.0]
-            A = AffineTransformation(M,v)
+            A = AffineMap(M,v)
             @test A(x) == M*x + v
         end
 
         @testset "composition " begin
             M1 = [1 2; 3 4]
             v1 = [-1, 1]
-            A1 = AffineTransformation(M1,v1)
+            A1 = AffineMap(M1,v1)
             M2 = [0 1; 1 0]
             v2 = [-2, 0]
-            A2 = AffineTransformation(M2,v2)
+            A2 = AffineMap(M2,v2)
             x = [1,0]
             y = [0,1]
             @test A1(x) == M1*x + v1
@@ -36,7 +36,7 @@ CoordinateTransformations.transform_deriv(::SquareMe, x0) = diagm(2*x0)
             v = [-1.0, 1.0]
             x = [1,0]
             y = [0.0,1.0]
-            A = AffineTransformation(M,v)
+            A = AffineMap(M,v)
             @test inv(A)(A(x)) ≈ x
             @test inv(A)(A(y)) ≈ y
         end
@@ -45,16 +45,16 @@ CoordinateTransformations.transform_deriv(::SquareMe, x0) = diagm(2*x0)
             S = SquareMe()
             x0 = [1,2,3]
             dx = 0.1*[1,-1,1]
-            A = AffineTransformation(S, x0)
+            A = AffineMap(S, x0)
             @test isapprox(S(x0 + dx), A(x0 + dx), atol=maximum(2*dx.^2))
         end
     end
 
-    @testset "LinearTransformation" begin
+    @testset "LinearMap" begin
         M = [1 2; 3 4]
         x = [1,0]
         y = [0,1]
-        L = LinearTransformation(M)
+        L = LinearMap(M)
         @test L(x) == M*x
         @test inv(L)(x) == inv(M)*x
         @test inv(L)(y) == inv(M)*y