text:
"""
max_err, errors = compare_dat(file1, file2, epsilon=1e-10)

Compute max_err, the maximum difference between common lines of both files, and
a dict associating an error to the line(s) where it occured.
"""
function compare_dat(file1::String, file2::String; epsilon = 1e-10, display_level=0)
  temp1, temp2 = "sorted_dat1.temp", "sorted_dat2.temp"

  sort_dat(file1, temp1)
  sort_dat(file2, temp2)

  data1, data2 = readdlm(temp1), readdlm(temp2)

  rm(temp1)
  rm(temp2)

  lines1 = Set([data1[i, 1]*data1[i, 2]*data1[i, 3]*data1[i, 4] for i=1:size(data1, 1)])
  lines2 = Set([data2[i, 1]*data2[i, 2]*data2[i, 3]*data2[i, 4] for i=1:size(data2, 1)])

  if size(data1, 1) != size(data2, 1)
    warn("dat files have different number of lines  ($(size(data1, 1)) and $(size(data2, 1)))")
  end

  if lines1 != lines2
    warn("dat files have different key entries\nfile1 \\ file2: $(length(setdiff(lines1, lines2)))\nfile2 \\ file1: $(length(setdiff(lines2, lines1)))")
  end

  if display_level>0
    println("nfile1 \\ file2: $(sort(collect(setdiff(lines1, lines2)))) \nfile2 \\ file1: $(sort(collect(setdiff(lines2, lines1))))")
  end

  errors = Dict{Float64, Any}()
  for i=1:min(size(data1, 1), size(data2, 1))
    if data1[i, 1:4] == data2[i, 1:4]
      cur_error = max(abs(data1[i, 5]-data2[i, 5]), abs(data1[i, 6]-data2[i, 6]))
      if cur_error > epsilon
        if !haskey(errors, cur_error)
          errors[cur_error] = Set()
        end
        push!(errors[cur_error], (i, data1[i, 1:4]))
      end
    else
      # warn("Compare_dat(): line $i - mismatched on line entry")
    end
  end

  max_coeff_err = 0
  if length(errors) > 0
    max_coeff_err = maximum(collect(keys(errors)))
  end
  return max_coeff_err, errors
end

"""
sort_dat(filename, outfile)

Writes an outfile dat file with lexicographically sorted lines from filename.
"""
function sort_dat(filename, outfile)
  lines = Set{String}()

  open(filename, "r") do f
    while !eof(f)
      line = readline(f)
      push!(lines, line)
    end
  end

  if isfile(outfile)
    rm(outfile)
  end

  open(outfile, "a") do f
    for line in sort(collect(lines))
      println(f, line)
    end
  end
end

max_stars_repo_name: Gimaju/GOC

max_issues_repo_name: Gimaju/GOC

max_forks_repo_name: Gimaju/GOC


text:
import Base

"""
Struct for WilsonFermion
"""
struct WilsonFermion_2D_wing{NC,NDW} <: WilsonFermion_2D{NC} #AbstractFermionfields_2D{NC}

    f::Array{ComplexF64,4}
    NC::Int64
    NX::Int64
    #NY::Int64
    #NZ::Int64
    NT::Int64
    NG::Int64
    NDW::Int64
    Dirac_operator::String
    #BoundaryCondition::Vector{Int8}

    function WilsonFermion_2D_wing(NC::T,NX::T,NT::T) where T<: Integer
        NG = 2
        NDW = 1
        #@assert NDW == 1 "only NDW = 1 is supported. Now NDW = $NDW"
        f = zeros(ComplexF64,NC,NX+2NDW,NT+2NDW,NG)
        Dirac_operator = "Wilson"
        return new{NC,NDW}(f,NC,NX,NT,NG,NDW,Dirac_operator)
    end

    function WilsonFermion_2D_wing{NC}(NX::T,NT::T) where {T<: Integer,NC}
        NG = 2
        NDW = 1
        #@assert NDW == 1 "only NDW = 1 is supported. Now NDW = $NDW"
        f = zeros(ComplexF64,NC,NX+2NDW,NT+2NDW,NG)
        Dirac_operator = "Wilson"
        return new{NC,NDW}(f,NC,NX,NT,NG,NDW,Dirac_operator)
    end

end

function Base.length(x::WilsonFermion_2D_wing{NC,NDW}) where {NC,NDW}
    return NC*x.NX*x.NT*x.NG
end

function Base.setindex!(x::WilsonFermion_2D_wing{NC,NDW},v,i1,i2,i5,i6)  where {NC,NDW}
    @inbounds x.f[i1,i2 + NDW,i5 + NDW,i6] = v
end

function Base.getindex(x::WilsonFermion_2D_wing{NC,NDW},i1,i2,i5,i6) where {NC,NDW}
    @inbounds return x.f[i1,i2 .+ NDW,i5 .+ NDW,i6]
end

function Base.getindex(x::WilsonFermion_2D_wing{NC,NDW},i1::N,i2::N,i5::N,i6::N) where {NC,NDW,N<: Integer}
    @inbounds return  x.f[i1,i2 + NDW,i5 + NDW,i6]
end

function Base.similar(x::T) where T <: WilsonFermion_2D_wing
    return WilsonFermion_2D_wing(x.NC,x.NX,x.NT)
end

function set_wing_fermion!(a::WilsonFermion_2D_wing{NC,NDW},boundarycondition) where {NC,NDW}
    NT = a.NT
    #NZ = a.NZ
    #NY = a.NY
    NX = a.NX
    NG = a.NG

    #!  X-direction
    for ialpha=1:NG
        for it=1:NT
            #for iz = 1:NZ
                #for iy=1:NY
                    @simd for k=1:NC
                        a[k,0, it,ialpha] = boundarycondition[1]*a[k,NX, it,ialpha]
                    end
                #end
            #end
        end
    end

    for ialpha=1:NG
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for k=1:NC
                        a[k,NX+1, it,ialpha] = boundarycondition[1]*a[k,1, it,ialpha]
                    end
                #end
            #end
        end
    end

    for ialpha=1:NG

        #T-direction
        #for iz=1:NZ
            #for iy=1:NY
                for ix=1:NX
                    @simd for k=1:NC
                        a[k,ix, 0,ialpha] = boundarycondition[2]*a[k,ix, NT,ialpha]
                        a[k,ix, NT+1,ialpha] =boundarycondition[2]*a[k,ix, 1,ialpha]
                    end
                end
            #end
        #end

    end

end

function set_wing_fermion!(a::WilsonFermion_2D_wing{NC,NDW},boundarycondition,iseven::Bool) where {NC,NDW}
    NT = a.NT
    #NZ = a.NZ
    #NY = a.NY
    NX = a.NX
    NG = a.NG

    #!  X-direction
    @inbounds for ialpha=1:NG
        for it=1:NT
            #for iz = 1:NZ
                #for iy=1:NY
                    ix = NX
                    evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                    if evenodd == iseven
                        @simd for k=1:NC
                            a[k,0, it,ialpha] = boundarycondition[1]*a[k,NX, it,ialpha]
                        end
                    end
                #end
            #end
        end
    end

    @inbounds for ialpha=1:NG
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    ix = 1
                    evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                    if evenodd == iseven
                        @simd for k=1:NC
                            a[k,NX+1, it,ialpha] = boundarycondition[1]*a[k,1, it,ialpha]
                        end
                    end
                #end
            #end
        end
    end

    @inbounds for ialpha=1:NG

        #T-direction
        #for iz=1:NZ
            #for iy=1:NY
                for ix=1:NX
                    it = NT
                    evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                    if evenodd == iseven
                        @simd for k=1:NC
                            a[k,ix, 0,ialpha] = boundarycondition[2]*a[k,ix, NT,ialpha]
                        end
                    end

                    it = 1
                    evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                    if evenodd == iseven
                        @simd for k=1:NC
                            a[k,ix, NT+1,ialpha] =boundarycondition[2]*a[k,ix, 1,ialpha]
                        end
                    end

                end
            #end
        #end

    end

end

function add_fermion!(c::WilsonFermion_2D_wing{NC,NDW},α::Number,a::T1,β::Number,b::T2,iseven) where {NC,NDW,T1 <: Abstractfermion,T2 <: Abstractfermion}#c += alpha*a + beta*b
    n1,n2,n5,n6 = size(c.f)

    @inbounds for i6=1:n6
        for i5=1:n5
            it = i5 -NDW
            #for i4=1:n4
                #iz = i4 -NDW
                #for i3=1:n3
                    #iy = i3 - NDW
                    for i2=1:n2
                        ix = i2 - NDW
                        evenodd = ifelse(( ix + it) % 2 == 0,true,false)
                        if evenodd == iseven
                            @simd for i1=1:NC
                                #println(a.f[i1,i2, i5,i6],"\t",b.f[i1,i2, i5,i6] )
                                c.f[i1,i2, i5,i6] += α*a.f[i1,i2, i5,i6] + β*b.f[i1,i2, i5,i6]
                            end
                        end
                    end
                #end
            #end
        end
    end
    return
end

function add_fermion!(c::WilsonFermion_2D_wing{NC,NDW},α::Number,a::T1,iseven::Bool) where {NC,NDW,T1 <: Abstractfermion,T2 <: Abstractfermion}#c += alpha*a + beta*b
    n1,n2, n5,n6 = size(c.f)

    @inbounds for i6=1:n6
        for i5=1:n5
            it = i5 -NDW
            #for i4=1:n4
                #iz = i4 -NDW
                #for i3=1:n3
                    #iy = i3 - NDW
                    for i2=1:n2
                        ix = i2 - NDW
                        evenodd = ifelse(( ix + it) % 2 == 0,true,false)
                        if evenodd == iseven
                            @simd for i1=1:NC
                                #println(a.f[i1,i2, i5,i6],"\t",b.f[i1,i2, i5,i6] )
                                c.f[i1,i2, i5,i6] += α*a.f[i1,i2, i5,i6]
                            end
                        end
                    end
                #end
            #end
        end
    end
    return
end

function WWx!(xout::T,U::Array{G,1},x::T,A)  where  {T <: WilsonFermion_2D_wing,G <: AbstractGaugefields} #(1 - K^2 Teo Toe) xe
    iseven = true
    isodd = false
    temp = A._temporary_fermi[7]#temps[4]
    temp2 = A._temporary_fermi[6]#temps[4]

    #println("Wx")
    #@time Wx!(xout,U,x,A)
    clear_fermion!(xout,iseven)

    #Tx!(temp,U,x,A)
    Toex!(temp,U,x,A,iseven) #Toe
    #Tx!(temp2,U,temp,A)
    Toex!(temp2,U,temp,A,isodd) #Teo

    #set_wing_fermion!(temp,A.boundarycondition)
    #add_fermion!(xout,1,x,-1,temp2)
    add_fermion!(xout,1,x,-1,temp2,iseven)
    set_wing_fermion!(xout,A.boundarycondition,iseven)

    #Wx!(xout,U,x,A)
    return

end

function WWdagx!(xout::T,U::Array{G,1},x::T,A)  where  {T <: WilsonFermion_2D_wing,G <: AbstractGaugefields} #(1 - K^2 Teo Toe) xe
    iseven = true
    isodd = false
    temp = A._temporary_fermi[7]#temps[4]
    temp2 = A._temporary_fermi[6]#temps[4]

    clear_fermion!(xout)

    #Tx!(temp,U,x,A)
    Tdagoex!(temp,U,x,A,iseven) #Toe
    #Tx!(temp2,U,temp,A)
    Tdagoex!(temp2,U,temp,A,isodd) #Teo

    #set_wing_fermion!(temp,A.boundarycondition)
    #add_fermion!(xout,1,x,-1,temp2)
    add_fermion!(xout,1,x,-1,temp2,iseven)
    set_wing_fermion!(xout,A.boundarycondition)

    return
end

function clear_fermion!(a::WilsonFermion_2D_wing{NC,NDW} ,iseven) where {NC,NDW}
    n1,n2, n5,n6 = size(a.f)
    @inbounds for i6=1:n6
        for i5=1:n5
            it = i5-NDW
            #for i4=1:n4
                #iz = i4-NDW
                #for i3=1:n3
                    #iy = i3 - NDW
                    for i2=1:n2
                        ix = i2 - NDW
                        evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                        if evenodd == iseven
                            @simd for i1=1:NC
                                a.f[i1,i2, i5,i6]= 0
                            end
                        end
                    end
                #end
            #end
        end
    end
end

function LinearAlgebra.mul!(x::WilsonFermion_2D_wing{NC,NDW},A::TA) where {TA <: AbstractMatrix, NC,NDW}
    NX = x.NX
    #NY = x.NY
    #NZ = x.NZ
    NT = x.NT

    #n6 = size(x.f)[6]
    #f = zeros(ComplexF64,4)
    #e = zeros(ComplexF64,4)

    for ic=1:NC
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for ix=1:NX
                            e1 = x[ic,ix, it,1]
                            e2 = x[ic,ix, it,2]
                            #e3 = x[ic,ix, it,3]
                            #e4 = x[ic,ix, it,4]

                            x[ic,ix, it,1] = A[1,1]*e1+A[1,2]*e2#+A[1,3]*e3+A[1,4]*e4
                            x[ic,ix, it,2] = A[2,1]*e1+A[2,2]*e2#+A[2,3]*e3+A[2,4]*e4
                            #x[ic,ix, it,3] = A[3,1]*e1+A[3,2]*e2#+A[3,3]*e3+A[3,4]*e4
                            #sx[ic,ix, it,4] = A[4,1]*e1+A[4,2]*e2#+A[4,3]*e3+A[4,4]*e4

                    end
                #end
            #end
        end
    end

end

function LinearAlgebra.mul!(x::WilsonFermion_2D_wing{NC,NDW},A::TA,iseven::Bool) where {TA <: AbstractMatrix, NC,NDW}
    NX = x.NX
    #NY = x.NY
    #NZ = x.NZ
    NT = x.NT

    #n6 = size(x.f)[6]
    #f = zeros(ComplexF64,4)
    #e = zeros(ComplexF64,4)

    for ic=1:NC
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for ix=1:NX
                        evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                        if evenodd == iseven
                            e1 = x[ic,ix, it,1]
                            e2 = x[ic,ix, it,2]
                            #e3 = x[ic,ix, it,3]
                            #e4 = x[ic,ix, it,4]

                            x[ic,ix, it,1] = A[1,1]*e1+A[1,2]*e2#+A[1,3]*e3+A[1,4]*e4
                            x[ic,ix, it,2] = A[2,1]*e1+A[2,2]*e2#+A[2,3]*e3+A[2,4]*e4
                            #x[ic,ix, it,3] = A[3,1]*e1+A[3,2]*e2+A[3,3]*e3+A[3,4]*e4
                            #x[ic,ix, it,4] = A[4,1]*e1+A[4,2]*e2+A[4,3]*e3+A[4,4]*e4
                        end
                    end
                #end
            #end
        end
    end

end

#function LinearAlgebra.mul!(xout::WilsonFermion_2D_wing{NC,NDW},A::TA,x::WilsonFermion_2D_wing{NC}) where {TA <: AbstractMatrix, NC,NDW}
function LinearAlgebra.mul!(xout::WilsonFermion_2D_wing{NC,NDW},A::TA,x::Abstractfermion) where {TA <: AbstractMatrix, NC,NDW}

    NX = xout.NX
    #NY = xout.NY
    #NZ = xout.NZ
    NT = xout.NT

    #n6 = size(x.f)[6]
    #f = zeros(ComplexF64,4)
    #e = zeros(ComplexF64,4)

    for ic=1:NC
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for ix=1:NX
                            e1 = x[ic,ix, it,1]
                            e2 = x[ic,ix, it,2]
                            #e3 = x[ic,ix, it,3]
                            #e4 = x[ic,ix, it,4]

                            xout[ic,ix, it,1] = A[1,1]*e1+A[1,2]*e2#+A[1,3]*e3+A[1,4]*e4
                            xout[ic,ix, it,2] = A[2,1]*e1+A[2,2]*e2#+A[2,3]*e3+A[2,4]*e4
                            #xout[ic,ix, it,3] = A[3,1]*e1+A[3,2]*e2+A[3,3]*e3+A[3,4]*e4
                            #xout[ic,ix, it,4] = A[4,1]*e1+A[4,2]*e2+A[4,3]*e3+A[4,4]*e4

                    end
                #end
            #end
        end
    end

end

function LinearAlgebra.mul!(xout::WilsonFermion_2D_wing{NC,NDW},A::TA,x::WilsonFermion_2D_wing{NC},iseven::Bool) where {TA <: AbstractMatrix, NC,NDW}
    NX = x.NX
    #NY = x.NY
    #NZ = x.NZ
    NT = x.NT

    #n6 = size(x.f)[6]
    #f = zeros(ComplexF64,4)
    #e = zeros(ComplexF64,4)

    for ic=1:NC
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for ix=1:NX
                        evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                        if evenodd == iseven
                            e1 = x[ic,ix, it,1]
                            e2 = x[ic,ix, it,2]
                            #e3 = x[ic,ix, it,3]
                            #e4 = x[ic,ix, it,4]

                            xout[ic,ix, it,1] = A[1,1]*e1+A[1,2]*e2#+A[1,3]*e3+A[1,4]*e4
                            xout[ic,ix, it,2] = A[2,1]*e1+A[2,2]*e2#+A[2,3]*e3+A[2,4]*e4
                            #xout[ic,ix, it,3] = A[3,1]*e1+A[3,2]*e2+A[3,3]*e3+A[3,4]*e4
                            #xout[ic,ix, it,4] = A[4,1]*e1+A[4,2]*e2+A[4,3]*e3+A[4,4]*e4
                        end

                    end
                #end
            #end
        end
    end

end

function LinearAlgebra.mul!(xout::WilsonFermion_2D_wing{NC,NDW},x::WilsonFermion_2D_wing{NC},A::TA) where {TA <: AbstractMatrix, NC,NDW}
    NX = x.NX
    #NY = x.NY
    #NZ = x.NZ
    NT = x.NT

    #n6 = size(x.f)[6]
    #f = zeros(ComplexF64,4)
    #e = zeros(ComplexF64,4)

    for ic=1:NC
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for ix=1:NX
                            e1 = x[ic,ix, it,1]
                            e2 = x[ic,ix, it,2]
                            #e3 = x[ic,ix, it,3]
                            #e4 = x[ic,ix, it,4]

                            xout[ic,ix, it,1] = A[1,1]*e1+A[2,1]*e2#+A[3,1]*e3+A[4,1]*e4
                            xout[ic,ix, it,2] = A[1,2]*e1+A[2,2]*e2#+A[3,2]*e3+A[4,2]*e4
                            #xout[ic,ix, it,3] = A[1,3]*e1+A[2,3]*e2+A[3,3]*e3+A[4,3]*e4
                            #xout[ic,ix, it,4] = A[1,4]*e1+A[2,4]*e2+A[3,4]*e3+A[4,4]*e4

                    end
                #end
            #end
        end
    end

end

function LinearAlgebra.mul!(xout::WilsonFermion_2D_wing{NC,NDW},x::AbstractFermionfields_2D{NC},A::TA) where {TA <: AbstractMatrix, NC,NDW}
    NX = x.NX
    #NY = x.NY
    #NZ = x.NZ
    NT = x.NT

    #n6 = size(x.f)[6]
    #f = zeros(ComplexF64,4)
    #e = zeros(ComplexF64,4)

    for ic=1:NC
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for ix=1:NX
                            e1 = x[ic,ix, it,1]
                            e2 = x[ic,ix, it,2]
                            #e3 = x[ic,ix, it,3]
                            #e4 = x[ic,ix, it,4]

                            xout[ic,ix, it,1] = A[1,1]*e1+A[2,1]*e2#+A[3,1]*e3+A[4,1]*e4
                            xout[ic,ix, it,2] = A[1,2]*e1+A[2,2]*e2#+A[3,2]*e3+A[4,2]*e4
                            #xout[ic,ix, it,3] = A[1,3]*e1+A[2,3]*e2+A[3,3]*e3+A[4,3]*e4
                            #xout[ic,ix, it,4] = A[1,4]*e1+A[2,4]*e2+A[3,4]*e3+A[4,4]*e4

                    end
                #end
            #end
        end
    end

end

function LinearAlgebra.mul!(xout::WilsonFermion_2D_wing{NC,NDW},x::WilsonFermion_2D_wing{NC},A::TA,iseven::Bool) where {TA <: AbstractMatrix, NC,NDW}
    NX = x.NX
    #NY = x.NY
    #NZ = x.NZ
    NT = x.NT

    #n6 = size(x.f)[6]
    #f = zeros(ComplexF64,4)
    #e = zeros(ComplexF64,4)

    for ic=1:NC
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    @simd for ix=1:NX
                        evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                        if evenodd == iseven
                            e1 = x[ic,ix, it,1]
                            e2 = x[ic,ix, it,2]
                            #e3 = x[ic,ix, it,3]
                            #e4 = x[ic,ix, it,4]

                            xout[ic,ix, it,1] = A[1,1]*e1+A[2,1]*e2#+A[3,1]*e3+A[4,1]*e4
                            xout[ic,ix, it,2] = A[1,2]*e1+A[2,2]*e2#+A[3,2]*e3+A[4,2]*e4
                            #xout[ic,ix, it,3] = A[1,3]*e1+A[2,3]*e2+A[3,3]*e3+A[4,3]*e4
                            #xout[ic,ix, it,4] = A[1,4]*e1+A[2,4]*e2+A[3,4]*e3+A[4,4]*e4
                        end
                    end
                #end
            #end
        end
    end

end

function LinearAlgebra.dot(a::WilsonFermion_2D_wing{NC,NDW},b::WilsonFermion_2D_wing{NC,NDW},iseven::Bool) where {NC,NDW}
    NT = a.NT
    #NZ = a.NZ
    #NY = a.NY
    NX = a.NX
    NG = a.NG

    c = 0.0im
    @inbounds for α=1:NG
        for it=1:NT
            #for iz=1:NZ
                #for iy=1:NY
                    for ix=1:NX
                        evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                        if evenodd == iseven
                            @simd for ic=1:NC
                                c+= conj(a[ic,ix, it,α])*b[ic,ix, it,α]
                            end
                        end
                    end
                #end
            #end
        end
    end
    return c
end

#Overwrite Y with X*a + Y*b, where a and b are scalars. Return Y.
function LinearAlgebra.axpby!(a::Number, X::T, b::Number, Y::WilsonFermion_2D_wing{NC,NDW},iseven::Bool) where {NC,NDW,T <: AbstractFermionfields_2D}
    n1,n2, n5,n6 = size(Y.f)
    #println("axpby")

    @inbounds for i6=1:n6
        for i5=1:n5
            it = i5+NDW
            #for i4=1:n4
                #iz = i4+NDW
                #for i3=1:n3
                    #iy = i3+NDW
                    for i2=1:n2
                        ix = i2+NDW
                        evenodd = ifelse(( ix+it) % 2 == 0,true,false)
                        if evenodd == iseven
                            @simd for i1=1:NC
                                Y.f[i1,i2, i5,i6] = a*X.f[i1,i2, i5,i6] + b*Y.f[i1,i2, i5,i6]
                            end
                        end
                    end
                #end
            #end
        end
    end
end

"""
c--------------------------------------------------------------------------c
c     y = sigma_3 * x
c     here
c                  ( 1       )
c        SIGMA3 =  (   -1     )
c--------------------------------------------------------------------------c
    """
    function mul_γ5x!(y::WilsonFermion_2D_wing{NC},x::WilsonFermion_2D_wing{NC}) where NC
        n1,n2, n5,n6 = size(x.f)
        @inbounds for i6=1:n6
            for i5=1:n5
                #it = i5+NDW
                #for i4=1:n4
                    #iz = i4+NDW
                    #for i3=1:n3
                        #iy = i3+NDW
                        for i2=1:n2
                            #ix = i2+NDW
                            @simd for ic=1:NC
                                y.f[i1,i2, i5,i6]=x.f[i1,i2, i5,i6]*ifelse(i6 == 2,-1,1)
                            end
                        end
                    #end
                #end
            end
        end

    end

    function apply_γ5!(x::WilsonFermion_2D_wing{NC}) where NC
        n1,n2, n5,n6 = size(x.f)
        #println("axpby")

        @inbounds for i6=1:n6
            for i5=1:n5
                #it = i5+NDW
                #for i4=1:n4
                    #iz = i4+NDW
                    #for i3=1:n3
                        #iy = i3+NDW
                        for i2=1:n2
                            #ix = i2+NDW
                            @simd for ic=1:NC
                                x.f[i1,i2, i5,i6]=x.f[i1,i2, i5,i6]*ifelse(i6 == 2,-1,1)
                            end
                        end
                    #end
                #end
            end
        end

    end

    #

    function mul_1plusγ5x!(y::WilsonFermion_2D_wing{NC},x::WilsonFermion_2D_wing{NC})  where NC#(1+gamma_5)/2
        NX = x.NX
        #NY = x.NY
        #NZ = x.NZ
        NT = x.NT
        #NC = x.NC
        for ic=1:NC
            for it=1:NT
                #for iz=1:NZ
                    #for iy=1:NY
                        @simd for ix=1:NX
                            y[ic,ix, it,1] = x[ic,ix, it,1]
                            y[ic,ix, it,2] = 0#-1*x[ic,ix, it,2]
                            #y[ic,ix, it,3] = x[ic,ix, it,3]
                            #y[ic,ix, it,4] = x[ic,ix, it,4]
                        end
                    #end
                #end
            end
        end
    end

    function mul_1plusγ5x_add!(y::WilsonFermion_2D_wing{NC},x::WilsonFermion_2D_wing{NC},factor) where NC#x = x +(1+gamma_5)/2
        NX = x.NX
        #NY = x.NY
        #NZ = x.NZ
        NT = x.NT
        #NC = x.NC
        for ic=1:NC
            for it=1:NT
                #for iz=1:NZ
                    #for iy=1:NY
                        @simd for ix=1:NX
                            y[ic,ix, it,1] += factor*x[ic,ix, it,1]
                            #y[ic,ix, it,4] += factor*x[ic,ix, it,4]
                        end
                    #end
                #end
            end
        end
    end

    function mul_1minusγ5x!(y::WilsonFermion_2D_wing{NC},x::WilsonFermion_2D_wing{NC}) where NC#(1-gamma_5)/2
        NX = x.NX
        #NY = x.NY
        #NZ = x.NZ
        NT = x.NT
        #NC = x.NC
        for ic=1:NC
            for it=1:NT
                #for iz=1:NZ
                    #for iy=1:NY
                        @simd for ix=1:NX
                            y[ic,ix, it,1] = 0#x[ic,ix, it,1]
                            y[ic,ix, it,2] = x[ic,ix, it,2]
                            #y[ic,ix, it,3] = 0#x[ic,ix, it,3]
                            #y[ic,ix, it,4] = 0#x[ic,ix, it,4]
                        end
                    #end
                #end
            end
        end
    end

    function mul_1minusγ5x_add!(y::WilsonFermion_2D_wing{NC},x::WilsonFermion_2D_wing{NC},factor) where NC#+(1-gamma_5)/2
        NX = x.NX
        #NY = x.NY
        #NZ = x.NZ
        NT = x.NT
        #NC = x.NC
        for ic=1:NC
            for it=1:NT
                #for iz=1:NZ
                    #for iy=1:NY
                        @simd for ix=1:NX
                            #y[ic,ix, it,1] += factor*x[ic,ix, it,1]
                            y[ic,ix, it,2] += factor*x[ic,ix, it,2]
                        end
                    #end
                #end
            end
        end
    end

ext: jl


text:
type SingleRelaxationTime{T <: AbstractFloat} <: Collision
    # Inverse of the relaxation time
    τ⁻¹::T
end

# Defines collision kernels for SRT
collision(τ⁻¹, fᵢ, feq) = τ⁻¹ * (feq - fᵢ)
collision(k::SingleRelaxationTime, fᵢ, feq) = collision(k.τ⁻¹, fᵢ, feq)
collision!(fᵢ, k::Collision, feq, site) = (fᵢ[:, site] += collision(k, fᵢ[:, site], feq))
# Applies collision operator onto fᵢ
collision!(fᵢ, k::SingleRelaxationTime, feq, site) = collision!(fᵢ, k.τ⁻¹, feq, site)
function collision!(fᵢ, τ⁻¹, feq, site)
    const n = size(fᵢ, 1) * (site - 1)
    for i = 1:length(feq)
        fᵢ[n+i] += collision(τ⁻¹, fᵢ[n+i], feq[i])
    end
end


text:
#===============================================================================

    AssignGenosResult.jl

    Author: Tom Price
    Date:   July 2019

===============================================================================#

import Clustering.ClusteringResult

struct AssignGenosResult
    cluster_result      ::ClusteringResult
    best_i              ::Int_T
    best_genos_combins  ::Vector{Matrix{Int_T}}
    expected_genos_all  ::Matrix{Int_T}
    ucc_dict            ::OrderedDict{Set{Vector{Float_T}},UniqCombinCenters}
end

## constants >>

const EMPTY_BEST_GENO_COMBINS = Vector{Matrix{Int_T}}()

## default values for processing preset calibration data with 4 groups
const DEFAULT_AMP_ENCGR = Array{Int_T,2}(0, 0)
## const DEFAULT_AMP_ENCGR = [0 1 0 1; 0 0 1 1] ## NTC, homo ch1, homo ch2, hetero
const DEFAULT_AMP_INIT_FACTORS = [1, 1, 1, 1] ## sometimes "hetero" may not have very high end-point fluo
const DEFAULT_AMP_APG_LABELS = ["ntc", "homo_1", "homo_2", "hetero", "unclassified"] ## [0 1 0 1; 0 0 1 1]
## const DEFAULT_AMP_APG_LABELS = ["hetero", "homo_2", "homo_1", "ntc", "unclassified"] ## [1 0 1 0; 1 1 0 0]

## 3 groups without NTC (non-template control)
# const DEFAULT_EGR = [1 0 1; 0 1 1] # homo ch1, homo ch2, hetero
# const DEFAULT_AMP_INIT_FACTORS = [1, 1, 1] # sometimes "hetero" may not have very high end-point fluo
# const DEFAULT_AMP_EG_LABELS = ["homo_a", "homo_b", "hetero", "unclassified"]

const DEFAULT_AMP_CTRL_WELL_DICT = OrderedDict{Vector{Int_T},Vector{Int_T}}()
## key is genotype (Vector{Int}), value is well numbers (Vector{Int_T})
## example
# const DEFAULT_AMP_CTRL_WELL_DICT = OrderedDict(
#     [0, 0] => [1, 2], # NTC, well 1 and 2
#     [1, 0] => [3, 4], # homo ch1, well 3 and 4
#     [0, 1] => [5, 6], # homo ch2, well 5 and 6
#     [1, 1] => [7, 8]  # hetero, well 7 and 8
# )
## old approach
# const DEFAULT_AMP_CTRL_WELL_DICT = DefaultOrderedDict(Vector{Int_T}, Vector{Int_T}, Vector{Int_T}())

const DEFAULT_AMP_CATEG_WELL_VEC = Vector{Pair{Symbol,Any}}([
    :rbbs_ary3      => Colon(),     ## calibrated_data
    :blsub_fluos    => Colon(), ## baseline_subtracted_data
    :d0             => Colon(),
    :cq             => Colon()])

# const DEFAULT_AMP_CYCS                  = 0
const DEFAULT_AMP_CLUSTER_METHOD        = k_means_medoids
const DEFAULT_AMP_NORM_L                = 2

max_stars_repo_name: MakerButt/chaipcr

max_issues_repo_name: MakerButt/chaipcr

max_forks_repo_name: MakerButt/chaipcr


text:
const global_application = Ref{Application}()

struct DisplayInline
    dom_function
end

"""
    with_session(f)::DisplayInline

calls f with the session, that will become active when displaying the result
of with_session. f is expected to return a valid DOM.
"""
function with_session(f)
    return DisplayInline(f)
end

const WebMimes = (
    MIME"text/html",
    MIME"application/prs.juno.plotpane+html",
    # MIME"application/vnd.webio.application+html"
)

function get_global_app()
    if !isassigned(global_application) || istaskdone(global_application[].server_task[])
        global_application[] = Application(
            (ctx, request)-> "Nothing to see",
            get(ENV, "WEBIO_SERVER_HOST_URL", "127.0.0.1"),
            parse(Int, get(ENV, "WEBIO_HTTP_PORT", "8081")),
            verbose = get(ENV, "JSCALL_VERBOSITY_LEVEL", "false") == "true"
        )
    end
    return global_application[]
end

for M in WebMimes
    @eval function Base.show(io::IO, m::$M, dom::DisplayInline)
        application = get_global_app()
        session_url = "/show"
        route!(application, session_url) do context
            # Serve the actual content
            return serve_dom(context, dom.dom_function)
        end
        # Display the route we just added in an iframe inline:
        url = repr(local_url(application, session_url))
        println(io, "<iframe src=$(url) style=\"position: absolute; height: 100%; width: 100%;border: none\">")
        println(io, "</iframe>")
    end
end

function Base.show(io::IO, m::MIME"application/vnd.webio.application+html", dom::DisplayInline)
    application = get_global_app()
    session = Session()
    application.sessions[session.id] = Dict("base" => session)
    dom = Base.invokelatest(dom.dom_function, session, (target = "/show",))
    dom2html(io, session, session.id, dom)
end


text:
#!/usr/bin/env julia

using Test, SafeTestsets

@time begin
@time @safetestset "New project settings" begin include("settings_test.jl") end
@time @safetestset "Routes HTML" begin include("routes_html_test.jl") end
@time @safetestset "Routes JSON" begin include("routes_json_test.jl") end
@time @safetestset "Routes Static" begin include("routes_static_test.jl") end
end


text:
using BayesianDataFusion
using Base.Test

X = sprand(50, 20, 0.1)

A = randn(50, 2);
B = randn(10, 2);

W = sparse(A * B')

rd = RelationData(W, class_cut = 0.5, feat1 = X)
assignToTest!(rd.relations[1], 50)

result = macau(rd, burnin = 1, psamples = 1, num_latent=5, verbose=false)

fdata = FastIDF(rd.relations[1].data)

### checking if sampling is same as single-threaded

## testing sample_user_basic
e1 = 1
e2 = 2
for i = 1:size(A,1)
  srand(i)
  s1 = BayesianDataFusion.sample_user2(rd.entities[e1], i, rd.entities[e1].model.mu, Int[e1], Vector{Int}[ Int[e2]])

  srand(i)
  s2 = BayesianDataFusion.sample_user_basic(i, fdata, e1, rd.relations[1].model.mean_value, rd.entities[e2].model.sample, 5.0, rd.entities[e1].model.mu, rd.entities[e1].model.Lambda)
  @test_approx_eq s1 s2
end


text:
#EasyPlotPlots: Render EasyPlot-plots using Plots.jl backend.
#-------------------------------------------------------------------------------
__precompile__(false)
#=
PROBLEM:
In Plots.jl, functions specific to a backend are added AFTER we add them with
the call to Plots.backend().

It seems like this causes issues when EasyPlotPlots gets precompiled (even
when __precompile__(false))... presumably because these functions are not
defined yet... so they don't get "precompiled" into this module.
=#
module EasyPlotPlots

#Hoping that environment of including module points to *correct* CMDimData:
import CMDimData
#Ensure *correct* modules are imported:
import CMDimData.EasyPlot #Avoid name collisions
using CMDimData.MDDatasets
using CMDimData.Colors
using Plots

import CMDimData.EasyPlot: Optional, Target, DS

include("base.jl")
include("defaults.jl")
include("builder.jl")

#==Initialization
===============================================================================#
function __init__()
	global defaults
	_initialize(defaults)

	EasyPlot.register(:EasyPlotPlots)
	return
end

end

#Last line


text:
## Source: Dan Getz https://stackoverflow.com/questions/44166177/julia-list-docstrings-inside-a-module

# Note: `isdefined` here is a workaround for a bug
# check if a symbol is a nested module
issubmodule(m::Module, s::Symbol) = isdefined(m,s) && isa(eval(m,s),Module) && module_name(m) != s

# get a list of all submodules of module m
submodules(m) = filter(x->issubmodule(m,x),names(m,true))

# get a list of all docstring bindings in a module
allbindings(m) = [ [y[2].data[:binding] for y in x[2].docs]
  for x in eval(m,Base.Docs.META)]

# recursively get all docstrings from a module and submodules
function getalldocs(m)
    thedocs = map(x->Base.Docs.doc(x[1]),allbindings(m))
    return vcat(thedocs,map(x->alldocs(eval(m,x)),submodules(m))...)
end

# Note: this test for Nothing is a workaround for a bug
function _findtypes(docs,thetype::DataType)
    inds = find(x -> !isa(x, Nothing) && isa(eval(docs[1].meta[:binding].mod,x.meta[:binding].var),thetype) , docs)
    return inds
end

printcategory(items) = foreach( x -> (display(x), print_with_color(:bold, "\n" * "-"^40 * "\n\n")), items)

"""
    alldocs(amodule)

Display all the docstrings in module `amodule`.
This is not perfect.
"""
function alldocs(amodule)
    docs = reverse!(getalldocs(amodule))
    allinds = collect(1:length(docs))
    indsmodules = _findtypes(docs,Module)
    indsfunctions0 = _findtypes(docs,Function)
    indstypes = _findtypes(docs,DataType)
    indsfunctions = setdiff(indsfunctions0, indstypes) # Constructors of types are together with types
    indsvars = setdiff(allinds,vcat(indsmodules,indsfunctions,indstypes))

    (modules,types,functions,data) = ([docs[x] for x in (indsmodules, indstypes, indsfunctions, indsvars)]...,)

    print_with_color(:bold, "MODULE ")
    print_with_color(:bold, modules[1].meta[:binding], "\n\n")
    printcategory(modules)
    print_with_color(:bold, "\nTYPES\n\n")
    printcategory(types)
    print_with_color(:bold, "\nFUNCTIONS\n\n")
    printcategory(functions)
    print_with_color(:bold, "\nDATA\n\n")
    printcategory(data)
end


text:
using Base.Meta

macro constants(array, stripprefix, expr)
    ret = Expr(:block)
    # Initialize the name lookup array
    push!(ret.args,:(const $array = Dict{UInt32,String}()))
    for e in expr.args
        if !isexpr(e,:const)
            continue
        end
        eq = e.args[1]
        @assert isexpr(eq,:(=))
        name = string(eq.args[1])
        name = replace(name,stripprefix,"",1)
        push!(ret.args,e)
        push!(ret.args,:($array[UInt32($(eq.args[1]))] = $name))
    end
    return esc(ret)
end

# # # DWARF TAG constants
@constants DW_TAG "" begin
    const DW_TAG_array_type = 0x01 #
    const DW_TAG_class_type = 0x02 #
    const DW_TAG_entry_point = 0x03 #
    const DW_TAG_enumeration_type = 0x04 #
    const DW_TAG_formal_parameter = 0x05 #
    const DW_TAG_imported_declaration = 0x08 #
    const DW_TAG_label = 0x0a #
    const DW_TAG_lexical_block = 0x0b #
    const DW_TAG_member = 0x0d #
    const DW_TAG_pointer_type = 0x0f #
    const DW_TAG_reference_type = 0x10 #
    const DW_TAG_compile_unit = 0x11 #
    const DW_TAG_string_type = 0x12 #
    const DW_TAG_structure_type = 0x13 #
    const DW_TAG_subroutine_type = 0x15 #
    const DW_TAG_typedef = 0x16 #
    const DW_TAG_union_type = 0x17 #
    const DW_TAG_unspecified_parameters = 0x18 #
    const DW_TAG_variant = 0x19 #
    const DW_TAG_common_block = 0x1a #
    const DW_TAG_common_inclusion = 0x1b #
    const DW_TAG_inheritance = 0x1c #
    const DW_TAG_inlined_subroutine = 0x1d #
    const DW_TAG_module = 0x1e #
    const DW_TAG_ptr_to_member_type = 0x1f #
    const DW_TAG_set_type = 0x20 #
    const DW_TAG_subrange_type = 0x21 #
    const DW_TAG_with_stmt = 0x22 #
    const DW_TAG_access_declaration = 0x23 #
    const DW_TAG_base_type = 0x24 #
    const DW_TAG_catch_block = 0x25 #
    const DW_TAG_const_type = 0x26 #
    const DW_TAG_constant = 0x27 #
    const DW_TAG_enumerator = 0x28 #
    const DW_TAG_file_type = 0x29 #
    const DW_TAG_friend = 0x2a #
    const DW_TAG_namelist = 0x2b #
    const DW_TAG_namelist_item = 0x2c #
    const DW_TAG_packed_type = 0x2d #
    const DW_TAG_subprogram = 0x2e #
    const DW_TAG_template_type_parameter = 0x2f #
    const DW_TAG_template_value_parameter = 0x30 #
    const DW_TAG_thrown_type = 0x31 #
    const DW_TAG_try_block = 0x32 #
    const DW_TAG_variant_part = 0x33 #
    const DW_TAG_variable = 0x34 #
    const DW_TAG_volatile_type = 0x35 #
    const DW_TAG_dwarf_procedure = 0x36 #
    const DW_TAG_restrict_type = 0x37 #
    const DW_TAG_interface_type = 0x38 #
    const DW_TAG_namespace = 0x39 #
    const DW_TAG_imported_module = 0x3a #
    const DW_TAG_unspecified_type = 0x3b #
    const DW_TAG_partial_unit = 0x3c #
    const DW_TAG_imported_unit = 0x3d #
    const DW_TAG_condition = 0x3f #
    const DW_TAG_shared_type = 0x40 #
    const DW_TAG_type_unit = 0x41 #
    const DW_TAG_rvalue_reference_type = 0x42 #
    const DW_TAG_template_alias = 0x43 #
    const DW_TAG_lo_user = 0x4080 #

    # GNU Extensions
    const DW_TAG_GNU_template_parameter_pack = 0x4107

    const DW_TAG_hi_user = 0xffff #
end

# # # DWARF child determination encodings
@constants DW_CHILDREN "" begin
    const DW_CHILDREN_no = 0x00 #
    const DW_CHILDREN_yes = 0x01 #
end

# # # DARF attribute encodings
@constants DW_AT "" begin
    const DW_AT_sibling = 0x01 # reference
    const DW_AT_location = 0x02 # exprloc, loclistptr
    const DW_AT_name = 0x03 # string
    const DW_AT_ordering = 0x09 # constant
    const DW_AT_byte_size = 0x0b # constant, exprloc, reference
    const DW_AT_bit_offset = 0x0c # constant, exprloc, reference
    const DW_AT_bit_size = 0x0d # constant, exprloc, reference
    const DW_AT_stmt_list = 0x10 # lineptr
    const DW_AT_low_pc = 0x11 # address
    const DW_AT_high_pc = 0x12 # address, constant
    const DW_AT_language = 0x13 # constant
    const DW_AT_discr = 0x15 # reference
    const DW_AT_discr_value = 0x16 # constant
    const DW_AT_visibility = 0x17 # constant
    const DW_AT_import = 0x18 # reference
    const DW_AT_string_length = 0x19 # exprloc, loclistptr
    const DW_AT_common_reference = 0x1a # reference
    const DW_AT_comp_dir = 0x1b # string
    const DW_AT_const_value = 0x1c # block, constant, string
    const DW_AT_containing_type = 0x1d # reference
    const DW_AT_default_value = 0x1e # reference
    const DW_AT_inline = 0x20 # constant
    const DW_AT_is_optional = 0x21 # flag
    const DW_AT_lower_bound = 0x22 # constant, exprloc, reference
    const DW_AT_producer = 0x25 # string
    const DW_AT_prototyped = 0x27 # flag
    const DW_AT_return_addr = 0x2a # exprloc, loclistptr
    const DW_AT_start_scope = 0x2c # Constant, rangelistptr
    const DW_AT_bit_stride = 0x2e # constant, exprloc, reference
    const DW_AT_upper_bound = 0x2f # constant, exprloc, reference
    const DW_AT_abstract_origin = 0x31 # reference
    const DW_AT_accessibility = 0x32 # constant
    const DW_AT_address_class = 0x33 # constant
    const DW_AT_artificial = 0x34 # flag
    const DW_AT_base_types = 0x35 # reference
    const DW_AT_calling_convention = 0x36 # constant
    const DW_AT_count = 0x37 # constant, exprloc, reference
    const DW_AT_data_member_location = 0x38 # constant, exprloc, loclistptr
    const DW_AT_decl_column = 0x39 # constant
    const DW_AT_decl_file = 0x3a # constant
    const DW_AT_decl_line = 0x3b # constant
    const DW_AT_declaration = 0x3c # flag
    const DW_AT_discr_list = 0x3d # block
    const DW_AT_encoding = 0x3e # constant
    const DW_AT_external = 0x3f # flag
    const DW_AT_frame_base = 0x40 # exprloc, loclistptr
    const DW_AT_friend = 0x41 # reference
    const DW_AT_identifier_case = 0x42 # constant
    const DW_AT_macro_info = 0x43 # macptr
    const DW_AT_namelist_item = 0x44 # reference
    const DW_AT_priority = 0x45 # reference
    const DW_AT_segment = 0x46 # exprloc, loclistptr
    const DW_AT_specification = 0x47 # reference
    const DW_AT_static_link = 0x48 # exprloc, loclistptr
    const DW_AT_type = 0x49 # reference
    const DW_AT_use_location = 0x4a # exprloc, loclistptr
    const DW_AT_variable_parameter = 0x4b # flag
    const DW_AT_virtuality = 0x4c # constant
    const DW_AT_vtable_elem_location = 0x4d # exprloc, loclistptr
    const DW_AT_allocated = 0x4e # constant, exprloc, reference
    const DW_AT_associated = 0x4f # constant, exprloc, reference
    const DW_AT_data_location = 0x50 # exprloc
    const DW_AT_byte_stride = 0x51 # constant, exprloc, reference
    const DW_AT_entry_pc = 0x52 # address
    const DW_AT_use_UTF8 = 0x53 # flag
    const DW_AT_extension = 0x54 # reference
    const DW_AT_ranges = 0x55 # rangelistptr
    const DW_AT_trampoline = 0x56 # address, flag, reference, string
    const DW_AT_call_column = 0x57 # constant
    const DW_AT_call_file = 0x58 # constant
    const DW_AT_call_line = 0x59 # constant
    const DW_AT_description = 0x5a # string
    const DW_AT_binary_scale = 0x5b # constant
    const DW_AT_decimal_scale = 0x5c # constant
    const DW_AT_small = 0x5d # reference
    const DW_AT_decimal_sign = 0x5e # constant
    const DW_AT_digit_count = 0x5f # constant
    const DW_AT_picture_string = 0x60 # string
    const DW_AT_mutable = 0x61 # flag
    const DW_AT_threads_scaled = 0x62 # flag
    const DW_AT_explicit = 0x63 # flag
    const DW_AT_object_pointer = 0x64 # reference
    const DW_AT_endianity = 0x65 # constant
    const DW_AT_elemental = 0x66 # flag
    const DW_AT_pure = 0x67 # flag
    const DW_AT_recursive = 0x68 # flag
    const DW_AT_signature = 0x69 # reference
    const DW_AT_main_subprogram = 0x6a # flag
    const DW_AT_data_bit_offset = 0x6b # constant
    const DW_AT_const_expr = 0x6c # flag
    const DW_AT_enum_class = 0x6d # flag
    const DW_AT_linkage_name = 0x6e # string
    const DW_AT_lo_user = 0x2000 # ---
    const DW_AT_hi_user = 0x3fff # ---

    const DW_AT_MIPS_loop_begin = 0x2002
    const DW_AT_MIPS_tail_loop_begin = 0x2003
    const DW_AT_MIPS_epilog_begin = 0x2004
    const DW_AT_MIPS_loop_unroll_factor = 0x2005
    const DW_AT_MIPS_software_pipeline_depth = 0x2006
    const DW_AT_MIPS_linkage_name = 0x2007
    const DW_AT_MIPS_stride = 0x2008
    const DW_AT_MIPS_abstract_name = 0x2009
    const DW_AT_MIPS_clone_origin = 0x200a
    const DW_AT_MIPS_has_inlines = 0x200b
    const DW_AT_MIPS_stride_byte = 0x200c
    const DW_AT_MIPS_stride_elem = 0x200d
    const DW_AT_MIPS_ptr_dopetype = 0x200e
    const DW_AT_MIPS_allocatable_dopetype = 0x200f
    const DW_AT_MIPS_assumed_shape_dopetype = 0x2010
end

# # # DW FORM constants
@constants DW_FORM "" begin
    const DW_FORM_addr = 0x01 # address
    const DW_FORM_block2 = 0x03 # block
    const DW_FORM_block4 = 0x04 # block
    const DW_FORM_data2 = 0x05 # constant
    const DW_FORM_data4 = 0x06 # constant
    const DW_FORM_data8 = 0x07 # constant
    const DW_FORM_string = 0x08 # string
    const DW_FORM_block = 0x09 # block
    const DW_FORM_block1 = 0x0a # block
    const DW_FORM_data1 = 0x0b # constant
    const DW_FORM_flag = 0x0c # flag
    const DW_FORM_sdata = 0x0d # constant
    const DW_FORM_strp = 0x0e # string
    const DW_FORM_udata = 0x0f # constant
    const DW_FORM_ref_addr = 0x10 # reference
    const DW_FORM_ref1 = 0x11 # reference
    const DW_FORM_ref2 = 0x12 # reference
    const DW_FORM_ref4 = 0x13 # reference
    const DW_FORM_ref8 = 0x14 # reference
    const DW_FORM_ref_udata = 0x15 # reference
    const DW_FORM_indirect = 0x16 # (see Section 7.5.3)
    const DW_FORM_sec_offset = 0x17 # lineptr, loclistptr, macptr, rangelistptr
    const DW_FORM_exprloc = 0x18 # exprloc
    const DW_FORM_flag_present = 0x19 # flag
    const DW_FORM_ref_sig8 = 0x20 # reference
end

# # # DWARF operation encodings
@constants DW_OP "" begin
    const DW_OP_addr = 0x03 # # 1 constant address
    const DW_OP_deref = 0x06 # # 0
    const DW_OP_const1u = 0x08 # 1 1-byte constant
    const DW_OP_const1s = 0x09 # 1 1-byte constant
    const DW_OP_const2u = 0x0a # 1 2-byte constant
    const DW_OP_const2s = 0x0b # 1 2-byte constant
    const DW_OP_const4u = 0x0c # 1 4-byte constant
    const DW_OP_const4s = 0x0d # 1 4-byte constant
    const DW_OP_const8u = 0x0e # 1 8-byte constant
    const DW_OP_const8s = 0x0f # 1 8-byte constant
    const DW_OP_constu = 0x10 # 1 ULEB128 constant
    const DW_OP_consts = 0x11 # 1 SLEB128 constant
    const DW_OP_dup = 0x12 # 0
    const DW_OP_drop = 0x13 # 0
    const DW_OP_over = 0x14 # 0
    const DW_OP_pick = 0x15 # 1 1-byte stack index
    const DW_OP_swap = 0x16 # 0
    const DW_OP_rot = 0x17 # 0
    const DW_OP_xderef = 0x18 # 0
    const DW_OP_abs = 0x19 # 0
    const DW_OP_and = 0x1a # 0
    const DW_OP_div = 0x1b # 0
    const DW_OP_minus = 0x1c # 0
    const DW_OP_mod = 0x1d # 0
    const DW_OP_mul = 0x1e # 0
    const DW_OP_neg = 0x1f # 0
    const DW_OP_not = 0x20 # 0
    const DW_OP_or = 0x21 # 0
    const DW_OP_plus = 0x22 # 0
    const DW_OP_plus_uconst = 0x23 # 1 ULEB128 addend
    const DW_OP_shl = 0x24 # 0
    const DW_OP_shr = 0x25 # 0
    const DW_OP_shra = 0x26 # 0
    const DW_OP_xor = 0x27 # 0
    const DW_OP_skip = 0x2f # 1 signed 2-byte constant
    const DW_OP_bra = 0x28 # 1 signed 2-byte constant
    const DW_OP_eq = 0x29 # 0
    const DW_OP_ge = 0x2a # 0
    const DW_OP_gt = 0x2b # 0
    const DW_OP_le = 0x2c # 0
    const DW_OP_lt = 0x2d # 0
    const DW_OP_ne = 0x2e # 0
    const DW_OP_lit1 = 0x31 # 0
    const DW_OP_lit31 = 0x4f # 0
    const DW_OP_reg0 = 0x50 # 0
    const DW_OP_reg31 = 0x6f # 0
    const DW_OP_breg0 = 0x70 # 1
    const DW_OP_breg31 = 0x8f # 1
    const DW_OP_regx = 0x90 # 1 ULEB128 register
    const DW_OP_fbreg = 0x91 # 1 SLEB128 offset
    const DW_OP_bregx = 0x92 # 2 ULEB128 register followed by SLEB128 offset
    const DW_OP_piece = 0x93 # 1 ULEB128 size of piece addressed
    const DW_OP_deref_size = 0x94 # 1 1-byte size of data retrieved
    const DW_OP_xderef_size = 0x95 # 1 1-byte size of data retrieved
    const DW_OP_nop = 0x96 # 0
    const DW_OP_push_object_address = 0x97 # 0
    const DW_OP_call2 = 0x98 # 1 2-byte offset of DIE
    const DW_OP_call4 = 0x99 # 1 4-byte offset of DIE
    const DW_OP_call_ref = 0x9a # 1 4- or 8-byte offset of DIE
    const DW_OP_form_tls_address = 0x9b # 0
    const DW_OP_call_frame_cfa = 0x9c # 0
    const DW_OP_bit_piece = 0x9d # 2 ULEB128 size followed by ULEB128 offset
    const DW_OP_implicit_value = 0x9e # 2 ULEB128 size followed by block of that size
    const DW_OP_stack_value = 0x9f # 0
    const DW_OP_lo_user = 0xe0
    const DW_OP_hi_user = 0xff #
end

# # # Base Type Attribute Encodings
@constants DW_ATE "" begin
    const DW_ATE_address = 0x01 #
    const DW_ATE_boolean = 0x02 #
    const DW_ATE_complex_float = 0x03 #
    const DW_ATE_float = 0x04 #
    const DW_ATE_signed = 0x05 #
    const DW_ATE_signed_char = 0x06 #
    const DW_ATE_unsigned = 0x07 #
    const DW_ATE_unsigned_char = 0x08 #
    const DW_ATE_imaginary_float = 0x09 #
    const DW_ATE_packed_decimal = 0x0a #
    const DW_ATE_numeric_string = 0x0b #
    const DW_ATE_edited = 0x0c #
    const DW_ATE_signed_fixed = 0x0d #
    const DW_ATE_unsigned_fixed = 0x0e #
    const DW_ATE_decimal_float = 0x0f #
    const DW_ATE_UTF = 0x10 #
    const DW_ATE_lo_user = 0x80 #
    const DW_ATE_hi_user = 0xff #
end

# # # Decimal sign encodings
@constants DW_DS "" begin
    const DW_DS_unsigned = 0x01 #
    const DW_DS_leading_overpunch = 0x02 #
    const DW_DS_trailing_overpunch = 0x03 #
    const DW_DS_leading_separate = 0x04 #
    const DW_DS_trailing_separate = 0x05 #
end

# # # Endianity Encodings
@constants DW_END "" begin
    const DW_END_default = 0x00 #
    const DW_END_big = 0x01 #
    const DW_END_little = 0x02 #
    const DW_END_lo_user = 0x40 #
    const DW_END_hi_user = 0xff #
end

# # # Accessibility Codes
@constants DW_ACCESS "" begin
    const DW_ACCESS_public = 0x01 #
    const DW_ACCESS_protected = 0x02 #
    const DW_ACCESS_private = 0x03 #
end

# # # Visibility Codes
@constants DW_VIS "" begin
    const DW_VIS_local = 0x01 #
    const DW_VIS_exported = 0x02 #
    const DW_VIS_qualified = 0x03 #
end

# # # Virtuality Codes
@constants DW_VIRTUALITY "" begin
    const DW_VIRTUALITY_none = 0x00 #
    const DW_VIRTUALITY_virtual = 0x01 #
    const DW_VIRTUALITY_pure_virtual = 0x02 #
end

# # # Language Encodings
@constants DW_LANG "" begin
    const DW_LANG_C89 = 0x0001 # 0
    const DW_LANG_C = 0x0002 # 0
    const DW_LANG_Ada83 = 0x0003 # 1
    const DW_LANG_C_plus_plus = 0x0004 # 0
    const DW_LANG_Cobol74 = 0x0005 # 1
    const DW_LANG_Cobol85 = 0x0006 # 1
    const DW_LANG_Fortran77 = 0x0007 # 1
    const DW_LANG_Fortran90 = 0x0008 # 1
    const DW_LANG_Pascal83 = 0x0009 # 1
    const DW_LANG_Modula2 = 0x000a # 1
    const DW_LANG_Java = 0x000b # 0
    const DW_LANG_C99 = 0x000c # 0
    const DW_LANG_Ada95 = 0x000d # 1
    const DW_LANG_Fortran95 = 0x000e # 1
    const DW_LANG_PLI = 0x000f # 1
    const DW_LANG_ObjC = 0x0010 # 0
    const DW_LANG_ObjC_plus_plus = 0x0011 # 0
    const DW_LANG_UPC = 0x0012 # 0
    const DW_LANG_D = 0x0013 # 0
    const DW_LANG_Python = 0x0014 # 0
    const DW_LANG_lo_user = 0x8000 #
    const DW_LANG_hi_user = 0xffff #
end

# # # Address Class Encodings
@constants DW_ADDR "" begin
    const DW_ADDR_NONE = 0
end

# # # Identifier Case Encodings
@constants DW_ID "" begin
    const DW_ID_case_sensitive = 0x00 #
    const DW_ID_up_case = 0x01 #
    const DW_ID_down_case = 0x02 #
    const DW_ID_case_insensitive = 0x03 #
end

# # # Calling convention encodings
@constants DW_CC "" begin
    const DW_CC_normal = 0x01 #
    const DW_CC_program = 0x02 #
    const DW_CC_nocall = 0x03 #
    const DW_CC_lo_user = 0x40 #
    const DW_CC_hi_user = 0xff #
end

# # # Inline encodings
@constants DW_INL "" begin
    const DW_INL_not_inlined = 0x00 #
    const DW_INL_inlined = 0x01 #
    const DW_INL_declared_not_inlined = 0x02 #
    const DW_INL_declared_inlined = 0x03 #
end

# # # Odering encodings
@constants DW_ORD "" begin
    const DW_ORD_row_major = 0x00 #
    const DW_ORD_col_major = 0x01 #
end

# # # Discriminant descriptor encodings
@constants DW_DSC "" begin
    const DW_DSC_label = 0x00 #
    const DW_DSC_range = 0x01 #
end

# # # Line Number Standard Opcode encodings
@constants DW_LNS "" begin
    const DW_LNS_copy = 0x01 #
    const DW_LNS_advance_pc = 0x02 #
    const DW_LNS_advance_line = 0x03 #
    const DW_LNS_set_file = 0x04 #
    const DW_LNS_set_column = 0x05 #
    const DW_LNS_negate_stmt = 0x06 #
    const DW_LNS_set_basic_block = 0x07 #
    const DW_LNS_const_add_pc = 0x08 #
    const DW_LNS_fixed_advance_pc = 0x09 #
    const DW_LNS_set_prologue_end = 0x0a #
    const DW_LNS_set_epilogue_begin = 0x0b #
    const DW_LNS_set_isa = 0x0c #
end

# # # Line Number Extended Opcode encodings
@constants DW_LNE "" begin
    const DW_LNE_end_sequence = 0x01 #
    const DW_LNE_set_address = 0x02 #
    const DW_LNE_define_file = 0x03 #
    const DW_LNE_set_discriminator = 0x04 #
    const DW_LNE_lo_user = 0x80 #
    const DW_LNE_hi_user = 0xff #
end

# # # Macinfo Type Encodings
@constants DW_MACINFO "" begin
    const DW_MACINFO_define = 0x01 #
    const DW_MACINFO_undef = 0x02 #
    const DW_MACINFO_start_file = 0x03 #
    const DW_MACINFO_end_file = 0x04 #
    const DW_MACINFO_vendor_ext = 0xff #
end

@constants DW_EH_PE "" begin
    # base
    const DW_EH_PE_absptr = 0x00
    const DW_EH_PE_omit = 0xff
    const DW_EH_PE_uleb128 = 0x01
    const DW_EH_PE_udata2 = 0x02
    const DW_EH_PE_udata4 = 0x03
    const DW_EH_PE_udata8 = 0x04
    const DW_EH_PE_signed = 0x08
    const DW_EH_PE_sleb128 = 0x09
    const DW_EH_PE_sdata2 = 0x0a
    const DW_EH_PE_sdata4 = 0x0b
    const DW_EH_PE_sdata8 = 0x0c
    # modifiers
    const DW_EH_PE_pcrel = 0x10
    const DW_EH_PE_textrel = 0x20
    const DW_EH_PE_datarel = 0x30
    const DW_EH_PE_funcrel = 0x40
    const DW_EH_PE_aligned = 0x50
    const DW_EH_PE_indirect = 0x80
end

@constants DW_CFA "" begin
    const DW_CFA_advance_loc        = 0x40 # + arbitrary lower bits
    const DW_CFA_offset             = 0x80 # + arbitrary lower bits
    const DW_CFA_restore            = 0xc0 # + arbitrary lower bits
    const DW_CFA_nop                = 0x00
    const DW_CFA_set_loc            = 0x01
    const DW_CFA_advance_loc1       = 0x02
    const DW_CFA_advance_loc2       = 0x03
    const DW_CFA_advance_loc4       = 0x04
    const DW_CFA_offset_extended    = 0x05
    const DW_CFA_restore_extended   = 0x06
    const DW_CFA_undefined          = 0x07
    const DW_CFA_same_value         = 0x08
    const DW_CFA_register           = 0x09
    const DW_CFA_remember_state     = 0x0a
    const DW_CFA_restore_state      = 0x0b
    const DW_CFA_def_cfa            = 0x0c
    const DW_CFA_def_cfa_register   = 0x0d
    const DW_CFA_def_cfa_offset     = 0x0e
    const DW_CFA_def_cfa_expression = 0x0f
    const DW_CFA_expression         = 0x10
    const DW_CFA_offset_extended_sf = 0x11
    const DW_CFA_def_cfa_sf         = 0x12
    const DW_CFA_def_cfa_offset_sf  = 0x13
    const DW_CFA_val_offset         = 0x14
    const DW_CFA_val_offset_sf      = 0x15
    const DW_CFA_val_expression     = 0x16
    const DW_CFA_lo_user            = 0x1c
    const DW_CFA_hi_user            = 0x3f
end


text:
using PMDPs
using Test

using POMDPSimulators
using POMDPs
using Random

mdp_mc = PMDPs.create_PMDP(PMDPg)
planner = PMDPs.get_MCTS_planner(mdp_mc)

rng = MersenneTwister(123)
hr = HistoryRecorder(max_steps=100, capture_exception=false, rng=rng)
h = simulate(hr, mdp_mc, planner)
trace = collect(eachstep(h, "s, a, r, info"))

PMDPs.LP.MILP_hindsight_pricing(mdp_mc, h, optimization_goal="utilization", verbose=false)


text:
"""
    fft_freqs(ts)

    Returns an array of DFT frequency points associated with the set of
    time-domain points.

    Assumes unit of argument `x` is sec. Output unit is in Hz (not rad/sec).
"""
function fft_freqs(ts)
    fs = (ts[2]-ts[1])^(-1) # sampling frequency
    N = Int(length(ts))
    deltaf = fs/N
    if N%2 ==0
        freqs = deltaf*(-N/2:N/2-1)
    else
        freqs = deltaf*(-(N-1)/2:(N-1)/2)
    end
    if length(ts) !== length(freqs)
        @printf("length(ts): %d, length(freqs): %d, delta_f: %f.\n",
                length(ts), length(freqs), deltaf)
        error("Number of time points should match the number of frequency
              points.")
    end
    return freqs
end


text:
using Images
using Plots

function get_patch_locations(unnormalized_locations; W=28, H=28, patchsize=8)
    locations = denormalize(H, unnormalized_locations)
    px = locations[1,:] .- div(patchsize,2) .+ 1
    py = locations[2,:] .- div(patchsize,2) .+ 1
    from_x, from_y = Int.(round.(px)), Int.(round.(py))
    to_x, to_y = from_x .+ patchsize, from_y .+ patchsize
    from_x, from_y = max.(1, from_x), max.(1, from_y)
    to_x, to_y = min.(W, to_x), min.(H, to_y)
    return from_x[1], from_y[1], to_x[1], to_y[1]
end

function unrolled_view(images...)
    full = cat(images..., dims=1)
    colorview(RGB, permutedims(full, (3,2,1)))
end

function draw_glimpse(img, location, patchsize=8; correct=true)
    W, H, C = size(img)[1:3]
    x = reshape(img, W, H, C)
    if C == 1
        x = repeat(x, 1, 1, 3)
    end
    x0, y0, x1, y1 = get_patch_locations(location; W=W, H=H,
                                         patchsize=patchsize)
    if !correct
        x[x0:x1,[y0,y1],1] .= 1.0;
        x[x0:x1,[y0,y1],2:3] .= 0.0;
        x[[x0,x1],y0:y1,1] .= 1.0;
        x[[x0,x1],y0:y1,2:3] .= 0.0;
    else
        x[x0:x1,[y0,y1],[1,3]] .= 0.0;
        x[x0:x1,[y0,y1],2] .= 1.0;
        x[[x0,x1],y0:y1,[1,3]] .= 0.0;
        x[[x0,x1],y0:y1,2] .= 1.0;
    end
    return x
end

function draw_glimpses(img, locations, patchsize=8; correct=true)
    map(li->draw_glimpse(img,li,patchsize; correct=correct), locations)
end

max_stars_repo_name: ilkerkesen/RAM

max_issues_repo_name: ilkerkesen/RAM

max_forks_repo_name: ilkerkesen/RAM