``````

In [1]:

x = ones(3)

``````
``````

Out[1]:

3-element Array{Float64,1}:
1.0
1.0
1.0

``````
``````

In [2]:

norm(x)

``````
``````

Out[2]:

1.7320508075688772

``````
``````

In [3]:

A = eye(3)

``````
``````

Out[3]:

3×3 Array{Float64,2}:
1.0  0.0  0.0
0.0  1.0  0.0
0.0  0.0  1.0

``````
``````

In [7]:

A = [1.0 2.0; 3.0 4.0]

``````
``````

Out[7]:

2×2 Array{Float64,2}:
1.0  2.0
3.0  4.0

``````
``````

In [8]:

det(A)

``````
``````

Out[8]:

-2.0

``````
``````

In [9]:

Ainv = inv(A)

``````
``````

Out[9]:

2×2 Array{Float64,2}:
-2.0   1.0
1.5  -0.5

``````
``````

In [10]:

A* Ainv

``````
``````

Out[10]:

2×2 Array{Float64,2}:
1.0          0.0
8.88178e-16  1.0

``````
``````

In [11]:

y = ones(2,1)

``````
``````

Out[11]:

2×1 Array{Float64,2}:
1.0
1.0

``````
``````

In [13]:

x = Ainv * y

``````
``````

Out[13]:

2×1 Array{Float64,2}:
-1.0
1.0

``````
``````

In [14]:

x = A /y

``````
``````

DimensionMismatch("left hand side has 1 rows, but right hand side has 2 rows")

in \(::Base.LinAlg.QRPivoted{Float64,Array{Float64,2}}, ::Array{Float64,2}) at ./linalg/qr.jl:654
in \(::Array{Float64,2}, ::Array{Float64,2}) at ./linalg/generic.jl:363
in /(::Array{Float64,2}, ::Array{Float64,2}) at ./linalg/generic.jl:367

``````
``````

In [15]:

evals, evecs = eig(A)

``````
``````

Out[15]:

([-0.372281,5.37228],
[-0.824565 -0.415974; 0.565767 -0.909377])

``````
``````

In [18]:

#here we try and miplement gram schmidt orthogonalisation for fun and testing

#params: X - an nxk array with linearly idnependent columns
#return U: an nxk array with orthonormal columns

function gram_schmidt(X)
n,k = size(X)
#we create our array to put everything in
U = Array{Float64}(n,k)
I = eye(n)

#first col of u is just normalised first col of x
v1 = X[:,1]
U[:,1] = v1/norm(v1)

#okay, now we begin the proper loop
for i in 2:k
#set up
b = X[:i] #get the col we want
Z = X[:, 1:i-1] # te first i-1 columns of X - i.e. the ones we've already sorted

#we project onto orthogonal complement of the col span of Z
M = I - Z *inv(Z' *Z)*Z' # this is the standard forumal
u = M*b
#and normalize
U[:,i] = u/norm(u)
end
return U
end

#not THAT difficult of a function. and it doesn't need any crazy numpy stuff to go
# fast either,  don't think. so that's very good indeed.

``````
``````

Out[18]:

gram_schmidt (generic function with 1 method)

``````
``````

In [19]:

#now some testing
y = [1 3 -3]'
X = [1 0; 0 -6; 2 2]

Py1 = X*inv(X'X)*X' *y

#gram schmidt
U = gram_schmidt(X)

``````
``````

indexing Array{Int64,2} with types Tuple{Symbol} is not supported

in gram_schmidt(::Array{Int64,2}) at ./In[18]:19

``````
``````

In [20]:

Q, R = qr(X)

``````
``````

Out[20]:

(
[-0.447214 -0.131876; 0.0 -0.989071; -0.894427 0.065938],

[-2.23607 -1.78885; 0.0 6.0663])

``````
``````

In [ ]:

``````