help?> struct
search: struct isstructtype 'mutable struct' unsafe_trunc

  struct
  The most commonly used kind of type in Julia is a struct, specified as a name and a set of fields.

  struct Point
      x
      y
  end

  Fields can have type restrictions, which may be parameterized:
  struct Point{X}
      x::X
      y::Float64
  end

  A struct can also declare an abstract super type via <: syntax:
  struct Point <: AbstractPoint
      x
      y
  end

  structs are immutable by default; an instance of one of these types cannot be modified after construction. Use mutable struct instead to declare a type whose instances can be
  modified.
  See the manual section on Composite Types for more details, such as how to define constructors.

struct ADI{T<:Real}     #mutable
    val::{T}
    der::{T}
    ADI() = new()       #unnecessary constructor
end

abstract type AbstractCustom end 
struct ADI <: AbstratCustom
    val     #::Float64, Vector{Float64}, etc
    der     #::Vector{SparseMatrixCSC{Float64, Int64}}, Vector{AbstratCustom}, etc
    ADI() = new()     #unnecessary constructor
end

julia> sparse(1:3,1:3,1.0)        #Sparse format
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 1.0   ⋅    ⋅ 
  ⋅   1.0   ⋅ 
  ⋅    ⋅   1.0

julia> a = sparse(1.0I, 3, 3)   # sparse(Matrix(1.0I, 3, 3)) || sparse([1. 0. 0.; 0. 1. 0.; 0. 0. 1.])
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 1.0   ⋅    ⋅ 
  ⋅   1.0   ⋅ 
  ⋅    ⋅   1.0

julia> Matrix(1.0I, 3, 3)        #Dense format || Array{Float64}(I,3,3)
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> sparse(Matrix(1.0I,3,3))  #convert from Dense to Sparse matrix(a n-by-n identity matrix)
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
 1.0   ⋅    ⋅ 
  ⋅   1.0   ⋅ 
  ⋅    ⋅   1.0

julia> A = sparse([1, 1, 2, 3], [1, 3, 2, 3], [0, 1, 2, 0])
                                 #3×3 SparseMatrixCSC{Int64, Int64} with 4 stored entries:
 0  ⋅  1
 ⋅  2  ⋅
 ⋅  ⋅  0

julia> dropzeros(A)              #Removes stored numerical zeros
3×3 SparseMatrixCSC{Int64, Int64} with 2 stored entries:
 ⋅  ⋅  1
 ⋅  2  ⋅
 ⋅  ⋅  ⋅

julia> spzeros(ni, nj)           #Creates a m-by-n matrix of zeros
3×3 SparseMatrixCSC{Float64, Int64} with 0 stored entries:
  ⋅    ⋅    ⋅ 
  ⋅    ⋅    ⋅ 
  ⋅    ⋅    ⋅ 

julia> a.m                      # Number of rows
3
julia> a.n                      # Number of columns
3
julia> a.colptr                 # Column j is in colptr[j]:(colptr[j+1]-1)
4-element Vector{Int64}:
 1
 2
 3
 4
julia> a.rowval                 # Row indices of stored values
3-element Vector{Int64}:
 1
 2
 3
julia> a.nzval                  # Stored values, typically nonzeros
3-element Vector{Float64}:
 1.0
 1.0
 1.0

function newtonMethodAD(X, tol, itrMax)
	for stp_i1 = 1:itrMax
		resi = [grad1Rosenbrock(X).val, grad2Rosenbrock(X).val]
		grad = Matrix[grad1Rosenbrock(X).der; grad2Rosenbrock(X).der]
		r1 = reshape(grad,2,1)[1]; r2 = reshape(grad,2,1)[2]; r3 = vcat(r1,r2)
		X = X - r3 \ resi
		if norm(resi,2) < tol
			return X, resi, grad, stp_i1
		end
	end
	return X, resi, grad, itrMax
end

function newtonMethodAD(x, y, tol, itrMax)
	for stp_i1 = 1:itrMax
		x = variableLAD(double(x), 1); y = variableLAD(double(y), 0)
		df1 = [grad1Rosenbrock(x,y).der grad2Rosenbrock(x,y).der]	#space
		x = variableLAD(double(x), 0); y = variableLAD(double(y), 1)
		df2 = [grad1Rosenbrock(x,y).der grad2Rosenbrock(x,y).der]	#space
		resi = [grad1Rosenbrock(x,y).val, grad2Rosenbrock(x,y).val]
		grad = vcat(df1, df2)
		x = x - (grad \ resi)[1]
		y = y - (grad \ resi)[2]
		if norm(resi,2) < tol
			return x, y, resi, grad, stp_i1
		end
	end
	return x, y, resi, grad, itrMax
end

function grad1Rosenbrock(X, a=1., b=100.)
	x, y = X
	return (2 * (x - a) - 4 * b * x * (y - x^2))
end
function grad2Rosenbrock(X, a=1., b=100.)
	x, y = X
	return (2 * b * (y - x^2))
end

module ForwardAD
using LinearAlgebra, SparseArrays
export FAD, variableFAD, double, assembleJacobianAD, assembleVariableAD, printFormatAD
import Base: -, +, *, /, ^, exp, sqrt, log, sin, cos, tan
import Base: inv, iterate, getindex, setindex!, == #for test

struct FAD
    val
    der
end

function variableFAD(argVal, argDer...)
	if isempty(argDer)
		argIn = (argVal,)
		mArg = length(argIn)
		argOut = Array{FAD}(undef,mArg)
		for i in 1:mArg
			der = Array{SparseMatrixCSC{Float64,Int64},1}(undef,mArg)
			[der[j] = i == j ? sparse(I, length(argIn[i]), length(argIn[i])) : 
                                      spzeros(length(argIn[i]), length(argIn[j])) 
                                      for j in 1:mArg]
			argOut[i] = FAD(argIn[i],der)
		end
		argOut[length(argOut)]
	else
		return (argVal, argDer...)
	end
end

+(A::FAD, B::Number) = FAD(A.val + B, A.der)
...

module LocalAD
export LAD, variableLAD, double, assembleJacobianAD, assembleVariableAD, printFormatAD
import Base: +, -, *, /, ^, sqrt, log, exp, sin, cos, tan

struct LAD
    val
    der
end

function variableLAD(val, derIndex::Int)
    der = derIndex > 0 ? 1 : 0
    return LAD(val, der)
end

import Base: +
function +(A::LAD, B::LAD)
    return LAD(A.val + B.val, A.der + B.der)
end
...

function assembleVariableAD(adObj)	#multiple dispatch (Array version)
	 # Assemble AD variable-Arrays depending on other independent AD variable-Arrays
    allVal = [getfield(ad, :val) for ad in adObj]
    allDer = [getfield(ad, :der) for ad in adObj]
    return LAD( vcat(allVal), vcat(allDer) )
end

function assembleVariableAD(adObj...)	#multiple dispatch (NOT Array version) 
	# Assemble AD variables depending on other independent AD variables
	argIn = [adObj...]
	if typeof(argIn)==Vector{LAD}	
      allVal = [getfield(ad, :val) for ad in argIn]
      allDer = [getfield(ad, :der) for ad in argIn]
		return LAD( allVal, allDer )
	else
		error("@Multiple dispatch #2 _assembleVariableAD error encountered.")
	end
end

julia> [1, 2, 3]                  #column vector
3-element Vector{Int64}:
 1
 2
 3
 
julia> [1; 2; 3]                  #column vector
3-element Vector{Int64}:
 1
 2
 3

julia> [1改行
        2改行
        3]                        #column vector
3-element Vector{Int64}:
 1
 2
 3

julia> [1␣2␣3]                  #row vector
1×3 Matrix{Int64}:
 1  2  3

julia> reshape([1, 2, 3], 1, 3)   #convert form column to row vector
1×3 Matrix{Int64}:
 1  2  3

julia> [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> Array{Type}(undef,m)           　 #|| Array{Type,1}(undef,m)
julia> Vector{Type}(undef,m)             #||

julia> Array{Float64,1}(undef,3)         #instance float64 1D array. values may not be initialzed by zero!
3-element Vector{Float64}:
 0.0
 6.9448778755838e-310
 6.9448778755877e-310

julia> Array{Float64,2}(undef,3,2)       #instance float64 2D array. values may not be initialzed by zero!
3×2 Matrix{Float64}:
 0.0           0.0
 6.94487e-310  6.94487e-310
 6.94487e-310  6.94487e-310

julia> Array{Float64,3}(undef,3,2,2)     #instance float64 3D array. values are not initialzed by zero!
3×2×2 Array{Float64, 3}:
[:, :, 1] =
 0.0           0.0
 6.94487e-310  6.94487e-310
 6.94487e-310  6.94487e-310

[:, :, 2] =
 0.0           0.0
 6.94487e-310  6.94487e-310
 6.94487e-310  6.94487e-310

julia> t = -0.5,4.0           #tuple
(-0.5, 4.0)

julia> a = collect(t)         #conver to column vector
2-element Vector{Float64}:
 -0.5
  4.0

julia> a = [1 2
            3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> a[:,:]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> a[1,:]
2-element Vector{Int64}:
 1
 2

julia> a[:,1]
2-element Vector{Int64}:
 1
 3
julia> a[begin:end,begin:end]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> getindex(a,1,2)      #find element at index @(1,2)
2

julia> setindex!(a,-1,3)    #reset value:-1 at index @4 (count by element-wise)
2×2 Matrix{Int64}:
 1  -1
 3   4

julia> a = [1 2;3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> a'                   #transpose
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  3
 2  4

julia> [1 2; 3 4]'          #transpose
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  3
 2  4

julia> b = [1␣2]           #row vector
1×2 Matrix{Int64}:
 1  2

julia> a .* b               #multiply by element wise
2×2 Matrix{Int64}:
 1  4
 3  8

julia> a * b                #multiply matrix by matrix         
ERROR: DimensionMismatch: arguments must have the same number of rows

julia> b .* b               #multiply by element-wise
1×2 Matrix{Int64}:
 1  4

julia> dot(b,b)             #inner product
5

julia> c = reshape(b,2,1)   #convert 1×2 Matrix to 2×1 Matrix
2×1 Matrix{Int64}:
 1
 2

julia> b * c                #multiply by matrix -> inner product
1×1 Matrix{Int64}:
 5

julia> sin(a)               #sin by matrix
2×2 Matrix{Float64}:
 -0.465581  -0.148424
 -0.222637  -0.688218

julia> sin.(a)              #sin by elementary-wise
2×2 Matrix{Float64}:
 0.841471  -0.841471
 0.14112   -0.756802

julia> a
2×2 Matrix{Int64}:
 1  2
 3  4

julia> b = a
2×2 Matrix{Int64}:
 1  2
 3  4

julia> c = copy(a)
2×2 Matrix{Int64}:
 1  2
 3  4

julia> a[1,1] = 0
0

julia> a
2×2 Matrix{Int64}:
 0  2
 3  4

julia> b
2×2 Matrix{Int64}:
 0  2
 3  4

julia> pointer(a)                       #pointer of a
Ptr{Int64} @0x00007fe9f22449a0

julia> pointer(b)
Ptr{Int64} @0x00007fe9f22449a0          #pointer of b == pointer of a

julia> pointer(c)
Ptr{Int64} @0x00007fe9f269a560

julia> a = Vector(1:0.5:2)             #initialize array by range == Array(1:0.5:2)
3-element Vector{Float64}:
 1.0
 1.5
 2.0

julia> zeros(Float64,3,2,1)            #initialize 3D array by zero
3×2×1 Array{Float64, 3}:
[:, :, 1] =
 0.0  0.0
 0.0  0.0
 0.0  0.0

julia> ones(Float64,3,2)               #initialize 3D array by one
3×2 Matrix{Float64}:
 1.0  1.0
 1.0  1.0
 1.0  1.0

julia> fill(1.0, 3,2)                  #Create an array of size dims set to value
3×2 Matrix{Float64}:
 1.0  1.0
 1.0  1.0
 1.0  1.0

julia> vcat(A...)                      #sparse_vcat(A...)
julia> vcat(a,a)                       #append vertically
4×2 Matrix{Int64}:
 1  2
 3  4
 1  2
 3  4

julia> hcat(A...)                      #sparse_hcat(A...)
julia> hcat(a,a)                       #append horizontally
2×4 Matrix{Int64}:
 1  2  1  2
 3  4  3  4

julia> maximum(a)                      #max of a's element
4

julia> minimum(a)                      #min of a's element
1

julia> extrema(a)                      #min & max of a's element
(1, 4)

julia> using LinearAlgebra             #should be declared
julia> Array{Float64}(I,3,3)           #initialize by Identity matrix
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> diag(a)                         #display diag element
2-element Vector{Int64}:
 1
 4

julia> Diagonal(a)                     #display diagonal array
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  4

julia> ndims(a)                        #find number of dimension
2

julia> length(a)                       #find number of toal elements
4

julia> a[:,:,:]                        #add one dimension
2×2×1 Array{Int64, 3}:
[:, :, 1] =
 1  2
 3  4

julia> a
2×2 Matrix{Int64}:
 1  2
 3  4
julia> b = [1 2]
1×2 Matrix{Int64}:
 1  2

julia> broadcast(+,a,b)
2×2 Matrix{Int64}:
 2  4
 4  6

julia> a .+ b
2×2 Matrix{Int64}:
 2  4
 4  6

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4
julia> map(x -> 2x, a)　　　　　　　　　　"broadcast to map function
2×2 Matrix{Int64}:
 2  4
 6  8

julia> exp.([1., 2., 3.])
3-element Vector{Float64}:
  2.718281828459045
  7.38905609893065
 20.085536923187668

julia> x = rand(3)
3-element Vector{Float64}:
 0.7914289957457029
 0.3167245428227382
 0.030360692693636726

julia> @. x^2 + 2x + 1　　　　　　　　　　"broadcast @. macro
3-element Vector{Float64}:
 3.209217846798458
 1.733763521671749
 1.0616431570481109

julia> a
2×2 Matrix{Int64}:
 1  2
 3  4

julia> b
1×2 Matrix{Int64}:
 1  2

julia> a ./ b          #divide by element-wise
2×2 Matrix{Float64}:
 1.0  1.0
 3.0  2.0

julia> x = a .\ b      #solve ax = b && divide by element-wise
2×2 Matrix{Float64}:
 1.0       1.0
 0.333333  0.5

julia> x = a \ b       #solve ax = b
ERROR: DimensionMismatch: arguments must have the same number of rows

julia> a
2×2 Matrix{Int64}:
 1  2
 3  4
 
julia> b = [1, 2]
2-element Vector{Int64}:
 1
 2

julia> a ./ b          #divide by element-wise
2×2 Matrix{Float64}:
 1.0  2.0
 1.5  2.0

julia> x = a .\ b      #solve ax = b && divide by element-wise
2×2 Matrix{Float64}:
 1.0       0.5
 0.666667  0.5

julia> x = a .\ reshape(b,1,2)
2×2 Matrix{Float64}:
 1.0       1.0
 0.333333  0.5

julia> x = a \ b       #solve ax = b
2-element Vector{Float64}:
 0.0
 0.5

julia> typeof(nothing)
Nothing

julia> typeof(a)          　                 #find type 
Matrix{Int64} (alias for Array{Int64, 2})

julia> x -> x^2 + 2x - 1                     #anonymous function: == function(x) = x^2 + 2x - 1
#1 (generic function with 1 method)

julia> map(x -> x^2 + 2x - 1, [1.,3.,-1.])   #useful for map function: x = [1.,3.,-1.]
3-element Vector{Float64}:
  2.0
 14.0
 -2.0

julia> function (x::Float64)                 #define argument-type
           x^2 + 2x - 1
       end
#1 (generic function with 1 method)

julia> function f(x::Float64)::Float64       #define return type
       end
f (generic function with 2 methods)


julia> function foo(a,b)                     #returning more than one variable
           return a+b, a*b
       end
foo (generic function with 1 method)

julia> bar(a,b,x...) = (a,b,x)               #variable number of arguments: 3+
bar (generic function with 1 method)

julia> bar(1,2,3)                            #variable number of arguments: 3
(1, 2, (3,))

julia> bar(1, 2, 3, 4)                       #variable number of arguments: 4
(1, 2, (3, 4))                               # 2 + one tuple (2)

julia> x = [3,4]                             #vector od 2 elements
2-element Array{Int64,1}:
 3
 4

julia> bar(1,2,x...)                         # 2 + one tuple (2)
(1, 2, (3, 4))

julia> isa(1.0, Int)     　                  #like isinstance in Python
false

julia> isa(Inf, Float64)                     #syntax:Inf
true

julia> isnothing(a)                          #syntax:isnothing
false

julia> isempty                               #syntax:isempty
false

julia> zip(bar,x)                            #tuple of values of its subiterators
zip((1, 2, (3, 4)), [3, 4])

julia> m = randn(2,2)
2×2 Matrix{Float64}:
 -1.17015   -0.281928
  0.247229   0.753965

julia> v = randn(2)
2-element Vector{Float64}:
 -0.6822660597240726
  0.19859284033102756

julia> @time m * v
  0.000015 seconds (1 allocation: 80 bytes)
2-element Vector{Float64}:
  0.7423622432902717
 -0.01894369984654759

julia> @benchmark m * v
BenchmarkTools.Trial: 10000 samples with 911 evaluations.
 Range (min … max):  118.530 ns …   3.364 μs  ┊ GC (min … max): 0.00% … 96.01%
 Time  (median):     121.145 ns               ┊ GC (median):    0.00%
 Time  (mean ± σ):   133.004 ns ± 120.911 ns  ┊ GC (mean ± σ):  3.57% ±  3.81%

  ▆█▃  ▃▃▂▂▁   ▁   ▁▃▁                                          ▁
  █████████████████████▇██▆▆▅▆▆▆▅▅▅▅▅▄▅▅▃▃▄▃▄▄▅▅▅▄▃▄▄▄▃▄▅▃▄▂▄▄▄ █
  119 ns        Histogram: log(frequency) by time        234 ns <

 Memory estimate: 80 bytes, allocs estimate: 1.

julia> eps(Float64)
2.220446049250313e-16

julia> eps(1.0)
2.220446049250313e-16