ityonemo

#elliptic.jl

#we'll make an "elliptic curve type" that is empty with no parameters.  The advantage to this is that the parameter values
#take no memory in the point representation and are JITted in as assembler immediates.
type EllipticCurve{A, B}; end

#properties of the elliptic curves
discriminant{A,B}(E::Type{EllipticCurve{A,B}}) = -16 * (4*A^3 + 27*B^2)
issmooth(E) = discriminant(E) != 0
haspoint{A,B}(E::Type{EllipticCurve{A,B}}, x, y) = y^2 == x^3 + A*x + B

ityonemo

## binary_tree_print.jl

#binary tree defined as the following:

type Tree{T}
  node::T
  left::Union{Tree{T}, Void}
  right::Union{Tree{T}, Void}
end

ityonemo

function magicsum(arg){
  var sumsofar = 0;
  var f;
 
  f = function(inner_arg){
    if (inner_arg){
      sumsofar += inner_arg;
      return f;
    } else {
      return sumsofar;

ityonemo

#supson.jl

type ツ; end
_(::Type{ツ}) = ツ
*(::Type{ツ}, ::Function) = ツ
type ⎺; end
Base.:\(::Type{⎺},::Type{ツ}) = ツ
Base.:/(::Type{ツ},::Type{⎺}) = true

⎺\_(ツ)_/⎺ #==> true

ityonemo

#bloom.jl - takes a file, reads binary data from the file and does whatever a
#bloom filter would do.

doc"""
  `BloomFilter{V}`
  defines a bloom filter over a value type V
"""
type BloomFilter{V}
  filter::BitVector
  hashes::Array{Function, 1}

ityonemo

function column_sort_inplace!(matrix::AbstractMatrix, fn::Function)
  p = sort_columns_return_permutation(matrix, fn)
  #first, find the permutation of the matrix, reduced by rows.
  #create an array that signals the completion status of the process.
  completion = falses(length(p))
  #store important indices
  current_root = 1 #root of the current cycle we're operating on.
  current_index = 1 #array index we're operating on.

  #next, allocate a short array that looks like the vector.

ityonemo

#drivingtaxes.jl

using JSON

#make sure we have what we're looking for.
(length(ARGS) == 0) && throw(ErrorException("needs a file name"))
###################################
#rows iterator
type rows; tgt::Matrix; end
Base.start(r::rows) = 1

ityonemo

#upper triangular indices - iterates over upper triangular indices in a list of
#indices.
type uppertriangular; iterable; end

Base.start(x::uppertriangular) = (1, 1)
function Base.next(x::uppertriangular, state)
  (idx1, idx2) = state
  next1 = idx1
  next2 = idx2 + 1
  if next2 > length(x.iterable)

ityonemo

Definitions:

ℝᵖ - projective reals. ℝᵖ/L - projective reals represented by a Type2 Unum Lattice L. The elements are intervals, which will be denoted as x̅. An element of may also be an exact value or an ulp value, which will be denoted as ẋ.

O:(ℝᵖ/L)ⁿ → ℝᵖ/L is an implementation of an operation o:(ℝᵖ)ⁿ → ℝᵖ. The implementation must have the property o(x) ∈ O(ẋ), where ẋ is the unique ulp

ityonemo

# converting from Int64 to UInt16 in Julia can result in a minefield of inexacterrors,
# which could be performance-debilitating (if you care about that).

code_native(Int16, (Int64,))  

# ==>(edited)
#  pushq  %rbp
#  movq   %rsp, %rbp
#  movswq %si, %rax
#  cmpq   %rsi, %rax