Miscellaneous code that is possibly useful for my SimpleWorld modules.

Several items dealing with linear algebra the were formerly in this package are moved to my LinearAlgebraX package.

Items include:

• eye
• Determinant functions
• Characteristic polynomial char_poly

We have also moved mod(z::Complex, m::Int) to the Mods package.

Dictionaries are like functions and so it makes sense to define a composition operation for them.

Suppose that f and g are dictionaries such that all the values in f appear as keys in g. Then, if k is any key of f the expression g[f[k]] is defined. In this case, we may compute g*f to yield a new dictionary h with the same keys as f and for which h[k] == g[f[k]] for all keys k.

Warnings are issued under the following circumstances:

• If some value of f is not a key of g.
• If the type of the values in f doesn't match the key type for g.

Here is an example without any warnings.

julia> f = Dict([("alpha", 1), ("bravo", 2)])
Dict{ASCIIString,Int64} with 2 entries:
  "alpha" => 1
  "bravo" => 2

julia> g = Dict([(1,3.14), (2,2.718), (3,1.618)])
Dict{Int64,Float64} with 3 entries:
  2 => 2.718
  3 => 1.618
  1 => 3.14

julia> g*f
Dict{ASCIIString,Float64} with 2 entries:
  "alpha" => 3.14
  "bravo" => 2.718

And this is an example in which problems arise that are not so serious that the composition fails:

julia> f = Dict([("alpha", 1), ("bravo", 2)])
Dict{ASCIIString,Int64} with 2 entries:
  "alpha" => 1
  "bravo" => 2

julia> g = Dict([(1.0, 3.33)])
Dict{Float64,Float64} with 1 entry:
  1.0 => 3.33

julia> g*f
WARNING: Dictionary type mismatch
WARNING: 1 keys were not mapped
Dict{ASCIIString,Float64} with 1 entry:
  "alpha" => 3.33

If one records the angle of a tangent vector as it traverses around a smooth closed curve, the values should be continuous. However, because there is a 2π ambiguity, one could see jumps. Here is an example.

If the angles are held in an array named y then the following will correct the problem.

julia> make_continuous!(y,2pi)

The resulting graph looks like this:

The flush_print function right (or left) justifies its argument in a String of a given number of characters.

• flush_print(x,width) returns a String version of x right justified in a string of length width.
• Use flush_print(x,width,false) for left-justified.

julia> flush_print("hello", 10)
"     hello"

julia> flush_print("hello", 10, false)
"hello     "

julia> flush_print(sqrt(10),30)
"            3.1622776601683795"

julia> flush_print(sqrt(10),5)
┌ Warning: Trunctated to fit width
└ @ SimpleTools ~/.julia/dev/SimpleTools/src/flush_print.jl:9
"3.162"

The sage function takes a one or two-dimensional matrix and outputs it in a way that can be copied and pasted into a Sage session.

julia> v = collect(1:5)
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

julia> sage(v)
Matrix([[1],[2],[3],[4],[5]])

sage: Matrix([[1],[2],[3],[4],[5]])
....:
[1]
[2]
[3]
[4]
[5]
sage:

For matrices A and B the function dcat(A,B) returns a new matrix of the form [A 0; 0 B] where the two 0s are zero blocks of the appropriate size. The function dcat can be called with any positive number of arguments.

julia> A = ones(Int,2,3)
2×3 Array{Int64,2}:
 1  1  1
 1  1  1

julia> dcat(A,2A)
4×6 Array{Int64,2}:
 1  1  1  0  0  0
 1  1  1  0  0  0
 0  0  0  2  2  2
 0  0  0  2  2  2

julia> dcat(A,2A')
5×5 Array{Int64,2}:
 1  1  1  0  0
 1  1  1  0  0
 0  0  0  2  2
 0  0  0  2  2
 0  0  0  2  2

julia> dcat(A,2A,3A)
6×9 Array{Int64,2}:
 1  1  1  0  0  0  0  0  0
 1  1  1  0  0  0  0  0  0
 0  0  0  2  2  2  0  0  0
 0  0  0  2  2  2  0  0  0
 0  0  0  0  0  0  3  3  3
 0  0  0  0  0  0  3  3  3