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

ityonemo

@macro printlndebug
  println("println")
end

#use:

function donothing()
  @printlndebug
  nothing
end

ityonemo

code_native(sign,(Float64,))
## note two jbe opcodes.  There are two jumps!
arry = rand(10000000) - 0.5
@time map(sign, arry)
# 0.38s
function sgn2(x::Float64)
  xp::UInt64 = reinterpret(UInt64, x)
  yp::UInt64 = ((xp & 0x7FFF_FFFF_0000_0000) >> 32) | (xp & 0x0000_0000_FFFF_FFFF)
  yp = (yp & 0xFFFF_0000 >> 16) | (yp & 0x0000_FFFF)
  yp = (yp & 0xFF00 >> 8) | (yp & 0x00FF)

ityonemo

using Base.Test
module X
  macro id(v)
    quote
      $v
    end
  end
  export @id
end