LowRankSketch

This package implements the following paper by Tropp, Yurtsever, Udell and Cevher on sketching methods for low rank matrix approximation.

@article{tropp2019streaming,
	title={Streaming Low-Rank Matrix Approximation with an Application to Scientific Simulation},
	author={Tropp, Joel A and Yurtsever, Alp and Udell, Madeleine and Cevher, Volkan},
	year={2019},
	archivePrefix = {arXiv},
	eprint = {1902.08651},
	journal={SIAM Scientific Computing (SISC)},
	url={http://epubs.siam.org/toc/sjoce3/41/4}
}

Syntax

This code uses standard Julia v0.6 syntax

• a type is a container for data
• <: and :: are type assertions; read them as "is a"
• a type can inherit from an abstract type. For example, the type statement

abstract type Bar end
type Foo<:Bar end

means that the type Foo inherits from the type Bar.

• functions are defined to take arguments of specific types. So, if we define

function say_hi(thing::Foo)
  print("hi, foo")
end

and call say_hi(Foo()), it will correctly print "hi, foo". But say_hi(5) will be an error, since 5 is not a Foo.

• If methods are not defined for the type, then they fall back to the default methods defined for the abstract type. For example,

function say_hello(thing::Bar)
  print("hello, bar")
end
f = Foo()
say_hello(f)

will print hello, bar. (f::Bar is true since Foo inherits from Bar.)

• curly brackets {} after a type or function name tell you that the types in curly brackets parametrize the type or function. So, eg, Matrix{Float64} is a matrix of floating point numbers with 64 bit precision. These are often used in this code to ensure that the field F (say, real or complex numbers) over which the (many) arguments of the function are defined is the same.

Differences with pseudocode

• The SparseDimRedux is not yet implemented
• The PSDSketch is not yet implemented