stevengj / PyCall.jl / 144

pending completion

Build # 144

Build Type

Pull #152

travis-ci

Committed by

swt30

Commit Message

<a href="https://github.com/stevengj/PyCall.jl/commit/<a class=hub.com/stevengj/PyCall.jl/commit/76642a52279711c3906ad62746bc3835e9f76dea">76642a522<a href="https://github.com/stevengj/PyCall.jl/commit/76642a52279711c3906ad62746bc3835e9f76dea">&quot;&gt;Revert &amp;quot;Fix 0.4-dev dlopen breakage, Fix #143&quot;

This reverts commit </a><a class="double-link" href="https://github.com/stevengj/PyCall.jl/commit/<a class="double-link" href="https://github.com/stevengj/PyCall.jl/commit/a497bf989c4b559d005607c0580dd59acab5fe19">a497bf989</a>">a497bf989</a><a href="https://github.com/stevengj/PyCall.jl/commit/76642a52279711c3906ad62746bc3835e9f76dea">.

Pull Request Pull Request #152: Revert "Fix 0.4-dev dlopen breakage, Fix #143"

Run Details

0 of 1334 relevant lines covered (0.0%)

0.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/numpy.jl

# Julia wrappers around the NumPy API, as part of the PyCall package

#########################################################################
# Initialization (UGLY)

# Linking NumPy's C API from Julia requires some serious hackery,
# because NumPy does not export its symbols in the usual way for
# shared libraries.  Instead, it provides a Python variable
# numpy.core.multiarray._ARRAY_API that points to a lookup table of
# pointers to the API functions and global variables.  Moreover, the
# meaning of this table, along with a lot of other important
# constants, is defined in a C header file which changes between NumPy
# versions, so we need to do some regex parsing of this header file in
# order to extract the necessary information to call NumPy.  Ugly and
# mildly insane, but I don't see much alternative (at least to do this
# purely in Julia).
#
# The result of npy_api_initialize, below, is to produce the following
# tables of API pointers:
npy_api = Dict{Symbol, Ptr{Void}}()

# type alias to shorten type decorations (needed for JIT) of our table
typealias Tnpy_api Dict{Symbol, Ptr{Void}}

# need a global to cache pyimport("numpy.core.multiarray"), in order
# to ensure the module is not garbage-collected as long as we are using it
# for the npy_api pointers.
npy_multiarray = PyObject()

npy_initialized = false # global to prevent multiple initializations

# Macro version of npyinitialize() to inline npy_initialized? check
macro npyinitialize()
    :(npy_initialized::Bool ? nothing : npyinitialize())
end

function npyinitialize()
    global npy_api
    global npy_initialized
    global npy_multiarray

    if npy_initialized::Bool
        return
    end
    try
        npy_multiarray::PyObject = pyimport("numpy.core.multiarray")
    catch e
        error("numpy.core.multiarray required for multidimensional Array conversions - ", e)
    end
    if pyversion < v"3.0"
        PyArray_API = @pychecki ccall((@pysym :PyCObject_AsVoidPtr), 
                                      Ptr{Ptr{Void}}, (PyPtr,), 
                                      (npy_multiarray::PyObject)["_ARRAY_API"])
    else
        PyArray_API = @pychecki ccall((@pysym :PyCapsule_GetPointer),
                                      Ptr{Ptr{Void}}, (PyPtr,Ptr{Void}), 
                            (npy_multiarray::PyObject)["_ARRAY_API"], C_NULL)
    end

    # directory for numpy include files to parse
    inc = pycall(pyimport("numpy")["get_include"], AbstractString)

    # Parse __multiarray_api.h to obtain length and meaning of PyArray_API
    try
        hdrfile = open(joinpath(inc, "numpy", "__multiarray_api.h"))
        hdr = readall(hdrfile);
        close(hdrfile)
    catch e
        error("could not read __multiarray_api.h to parse PyArray_API ", e)
    end
    hdr = replace(hdr, r"\\\s*\n", " "); # rm backslashed newlines
    r = r"^#define\s+([A-Za-z]\w*)\s+\(.*\bPyArray_API\s*\[\s*([0-9]+)\s*\]\s*\)\s*$"m # regex to match #define PyFoo (... PyArray_API[nnn])
    PyArray_API_length = 0
    for m in eachmatch(r, hdr) # search for max index into PyArray_API 
        PyArray_API_length = max(PyArray_API_length, parse(Int, m.captures[2])+1)
    end
    API = pointer_to_array(PyArray_API, (PyArray_API_length,))
    for m in eachmatch(r, hdr) # build npy_api table
        (npy_api::Tnpy_api)[symbol(m.captures[1])] = API[parse(Int, m.captures[2])+1]
    end
    if !haskey(npy_api::Tnpy_api, :PyArray_New)
        error("failure parsing NumPy PyArray_API symbol table")
    end

    npy_initialized::Bool = true
    return
end

function npyfinalize()
    global npy_api
    global npy_initialized
    global npy_multiarray

    if npy_initialized::Bool
        empty!(npy_api::Tnpy_api)
        pydecref(npy_multiarray::PyObject)
        npy_initialized::Bool = false
    end
    return
end

#########################################################################
# Hard-coded constant values, copied from numpy/ndarraytypes.h ...
# the values of these seem to have been stable for some time, and
# the NumPy developers seem to have some awareness of binary compatibility

# NPY_TYPES:

@compat begin
const NPY_BOOL = Int32(0)
const NPY_BYTE = Int32(1)
const NPY_UBYTE = Int32(2)
const NPY_SHORT = Int32(3)
const NPY_USHORT = Int32(4)
const NPY_INT = Int32(5)
const NPY_UINT = Int32(6)
const NPY_LONG = Int32(7)
const NPY_ULONG = Int32(8)
const NPY_LONGLONG = Int32(9)
const NPY_ULONGLONG = Int32(10)
const NPY_FLOAT = Int32(11)
const NPY_DOUBLE = Int32(12)
const NPY_LONGDOUBLE = Int32(13)
const NPY_CFLOAT = Int32(14)
const NPY_CDOUBLE = Int32(15)
const NPY_CLONGDOUBLE = Int32(16)
const NPY_OBJECT = Int32(17)
const NPY_STRING = Int32(18)
const NPY_UNICODE = Int32(19)
const NPY_VOID = Int32(20)

# NPY_ORDER:
const NPY_ANYORDER = Int32(-1)
const NPY_CORDER = Int32(0)
const NPY_FORTRANORDER = Int32(1)

# flags:
const NPY_ARRAY_C_CONTIGUOUS = Int32(1)
const NPY_ARRAY_F_CONTIGUOUS = Int32(2)
const NPY_ARRAY_ALIGNED = Int32(0x0100)
const NPY_ARRAY_WRITEABLE = Int32(0x0400)
const NPY_ARRAY_OWNDATA = Int32(0x0004)
const NPY_ARRAY_ENSURECOPY = Int32(0x0020)
const NPY_ARRAY_ENSUREARRAY = Int32(0x0040)
const NPY_ARRAY_FORCECAST = Int32(0x0010)
const NPY_ARRAY_UPDATEIFCOPY = Int32(0x1000)
const NPY_ARRAY_NOTSWAPPED = Int32(0x0200)
const NPY_ARRAY_ELEMENTSTRIDES = Int32(0x0080)
end

#########################################################################
# conversion from Julia types to NPY_TYPES constant

npy_type(::Type{Bool}) = NPY_BOOL
npy_type(::Type{Int8}) = NPY_BYTE
npy_type(::Type{Uint8}) = NPY_UBYTE
npy_type(::Type{Int16}) = NPY_SHORT
npy_type(::Type{Uint16}) = NPY_USHORT
npy_type(::Type{Int32}) = NPY_INT
npy_type(::Type{Uint32}) = NPY_UINT
npy_type(::Type{Int64}) = NPY_LONGLONG
npy_type(::Type{Uint64}) = NPY_ULONGLONG
npy_type(::Type{Float32}) = NPY_FLOAT
npy_type(::Type{Float64}) = NPY_DOUBLE
npy_type(::Type{Complex64}) = NPY_CFLOAT
npy_type(::Type{Complex128}) = NPY_CDOUBLE
npy_type(::Type{PyPtr}) = NPY_OBJECT

typealias NPY_TYPES Union(Bool,Int8,Uint8,Int16,Uint16,Int32,Uint32,Int64,Uint64,Float32,Float64,Complex64,Complex128,PyPtr)

# conversions from __array_interface__ type strings to supported Julia types
const npy_typestrs = @compat Dict( "b1"=>Bool,
                                   "i1"=>Int8,      "u1"=>Uint8,
                                   "i2"=>Int16,     "u2"=>Uint16,
                                   "i4"=>Int32,     "u4"=>Uint32,
                                   "i8"=>Int64,     "u8"=>Uint64,
                                   "f4"=>Float32,   "f8"=>Float64,
                                   "c8"=>Complex64, "c16"=>Complex128,
                                   "O$(div(WORD_SIZE,8))"=>PyPtr )

#########################################################################
# no-copy conversion of Julia arrays to NumPy arrays.

function PyObject{T<:NPY_TYPES}(a::StridedArray{T})
    try
        @npyinitialize
        p = @pychecki ccall(npy_api[:PyArray_New], PyPtr,
              (PyPtr,Cint,Ptr{Int},Cint, Ptr{Int},Ptr{T}, Cint,Cint,PyPtr),
              npy_api[:PyArray_Type], 
              ndims(a), Int[size(a)...], npy_type(T),
              Int[strides(a)...] * sizeof(eltype(a)), a, sizeof(eltype(a)),
              NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE,
              C_NULL)
        return PyObject(p, a)
    catch e
        array2py(a) # fallback to non-NumPy version
    end
end

#########################################################################
# Extract shape and other information about a NumPy array.  We need
# to call the Python interface to do this, since the equivalent information
# in NumPy's C API is only available via macros (or parsing structs).
# [ Hopefully, this will be improved in a future NumPy version. ]

type PyArray_Info
    T::Type
    native::Bool # native byte order?
    sz::Vector{Int}
    st::Vector{Int} # strides, in multiples of bytes!
    data::Ptr{Void}
    readonly::Bool

    function PyArray_Info(a::PyObject)
        ai = PyDict{AbstractString,PyObject}(a["__array_interface__"])
        typestr = convert(AbstractString, ai["typestr"])
        T = npy_typestrs[typestr[2:end]]
        datatuple = convert(@compat(Tuple{Int,Bool}), ai["data"])
        sz = convert(Vector{Int}, ai["shape"])
        local st
        try
            st = isempty(sz) ? Int[] : convert(Vector{Int}, ai["strides"])
        catch
            # default is C-order contiguous 
            st = similar(sz)
            st[end] = sizeof(T)
            for i = length(sz)-1:-1:1
                st[i] = st[i+1]*sz[i+1]
            end
        end
        return new(T,
                   (ENDIAN_BOM == 0x04030201 && typestr[1] == '<')
                   || (ENDIAN_BOM == 0x01020304 && typestr[1] == '>') 
                   || typestr[1] == '|',
                   sz, st,
                   convert(Ptr{Void}, datatuple[1]),
                   datatuple[2])
    end
end

aligned(i::PyArray_Info) = #  FIXME: also check pointer alignment?
  all(m -> m == 0, mod(i.st, sizeof(i.T))) # strides divisible by elsize

# whether a contiguous array in column-major (Fortran, Julia) order
function f_contiguous(T::Type, sz::Vector{Int}, st::Vector{Int})
    if prod(sz) == 1
        return true
    end
    if st[1] != sizeof(T)
        return false
    end
    for j = 2:length(st)
        if st[j] != st[j-1] * sz[j-1]
            return false
        end
    end
    return true
end

f_contiguous(i::PyArray_Info) = f_contiguous(i.T, i.sz, i.st)
c_contiguous(i::PyArray_Info) = f_contiguous(i.T, flipdim(i.sz,1), flipdim(i.st,1))

#########################################################################
# PyArray: no-copy wrapper around NumPy ndarray
#
# Hopefully, in the future this can be a subclass of StridedArray (see
# Julia issue #2345), which will allow it to be used with most Julia
# functions, but that is not possible at the moment.  So, to use this
# with Julia linalg functions etcetera a copy is still required.

type PyArray{T,N} <: AbstractArray{T,N}
    o::PyObject
    info::PyArray_Info
    dims::Dims
    st::Vector{Int}
    f_contig::Bool
    c_contig::Bool
    data::Ptr{T}

    function PyArray(o::PyObject, info::PyArray_Info)
        if !aligned(info)
            throw(ArgumentError("only NPY_ARRAY_ALIGNED arrays are supported"))
        elseif !info.native
            throw(ArgumentError("only native byte-order arrays are supported"))
        elseif info.T != T
            throw(ArgumentError("inconsistent type in PyArray constructor"))
        elseif length(info.sz) != N || length(info.st) != N
            throw(ArgumentError("inconsistent ndims in PyArray constructor"))
        end
        return new(o, info, tuple(info.sz...), div(info.st, sizeof(T)),
                   f_contiguous(info), c_contiguous(info),
                   convert(Ptr{T}, info.data))
    end
end

function PyArray(o::PyObject)
    info = PyArray_Info(o)
    return PyArray{info.T, length(info.sz)}(o, info)
end

size(a::PyArray) = a.dims
ndims{T,N}(a::PyArray{T,N}) = N

similar(a::PyArray, T, dims::Dims) = Array(T, dims)

function copy{T,N}(a::PyArray{T,N}) 
    if N > 1 && a.c_contig # equivalent to f_contig with reversed dims
        B = pointer_to_array(a.data, ntuple(N, n -> a.dims[N - n + 1]))
        return N == 2 ? transpose(B) : permutedims(B, (N:-1:1))
    end
    A = Array(T, a.dims)
    if a.f_contig
        ccall(:memcpy, Void, (Ptr{T}, Ptr{T}, Int), A, a, sizeof(T)*length(a))
        return A
    else
        return copy!(A, a)
    end
end

# TODO: need to do bounds-checking of these indices!

getindex{T}(a::PyArray{T,0}) = unsafe_load(a.data)
getindex{T}(a::PyArray{T,1}, i::Integer) = unsafe_load(a.data, 1 + (i-1)*a.st[1])

getindex{T}(a::PyArray{T,2}, i::Integer, j::Integer) = 
  unsafe_load(a.data, 1 + (i-1)*a.st[1] + (j-1)*a.st[2])

function getindex(a::PyArray, i::Integer) 
    if a.f_contig
        return unsafe_load(a.data, i)
    else
        return a[ind2sub(a.dims, i)...]
    end
end

function getindex(a::PyArray, is::Integer...)
    index = 1
    n = min(length(is),length(a.st))
    for i = 1:n
        index += (is[i]-1)*a.st[i]
    end
    for i = n+1:length(is)
        if is[i] != 1
            throw(BoundsError())
        end
    end
    unsafe_load(a.data, index)
end

function writeok_assign(a::PyArray, v, i::Integer)
    if a.info.readonly
        throw(ArgumentError("read-only PyArray"))
    else
        unsafe_store!(a.data, v, i)
    end
    return a
end

setindex!{T}(a::PyArray{T,0}, v) = writeok_assign(a, v, 1)
setindex!{T}(a::PyArray{T,1}, v, i::Integer) = writeok_assign(a, v, 1 + (i-1)*a.st[1])

setindex!{T}(a::PyArray{T,2}, v, i::Integer, j::Integer) = 
  writeok_assign(a, v, 1 + (i-1)*a.st[1] + (j-1)*a.st[2])

function setindex!(a::PyArray, v, i::Integer) 
    if a.f_contig
        return writeok_assign(a, v, i)
    else
        return setindex!(a, v, ind2sub(a.dims, i)...)
    end
end

function setindex!(a::PyArray, v, is::Integer...)
    index = 1
    n = min(length(is),length(a.st))
    for i = 1:n
        index += (is[i]-1)*a.st[i]
    end
    for i = n+1:length(is)
        if is[i] != 1
            throw(BoundsError())
        end
    end
    writeok_assign(a, v, index)
end

stride(a::PyArray, i::Integer) = a.st[i]

if VERSION < v"0.4.0-dev+3710"
    convert{T}(::Type{Ptr{T}}, a::PyArray{T}) = a.data
else
    Base.unsafe_convert{T}(::Type{Ptr{T}}, a::PyArray{T}) = a.data
end

pointer(a::PyArray, i::Int) = pointer(a, ind2sub(a.dims, i))

function pointer{T}(a::PyArray{T}, is::@compat Tuple{Vararg{Int}})
    offset = 0
    for i = 1:length(is)
        offset += (is[i]-1)*a.st[i]
    end
    return a.data + offset*sizeof(T)
end

summary{T}(a::PyArray{T}) = string(Base.dims2string(size(a)), " ",
                                   string(T), " PyArray")

#########################################################################
# PyArray <-> PyObject conversions

PyObject(a::PyArray) = a.o

convert(::Type{PyArray}, o::PyObject) = PyArray(o)

function convert{T<:NPY_TYPES}(::Type{Array{T, 1}}, o::PyObject)
    try
        copy(PyArray{T, 1}(o, PyArray_Info(o))) # will check T and N vs. info
    catch
        len = @pycheckzi ccall((@pysym :PySequence_Size), Int, (PyPtr,), o)
        A = Array(pyany_toany(T), len)
        py2array(T, A, o, 1, 1)
    end
end

function convert{T<:NPY_TYPES}(::Type{Array{T}}, o::PyObject)
    try
        info = PyArray_Info(o)
        try
            copy(PyArray{T, length(info.sz)}(o, info)) # will check T == info.T
        catch
            return py2array(T, Array(pyany_toany(T), info.sz...), o, 1, 1)
        end
    catch
        py2array(T, o)
    end
end

function convert{T<:NPY_TYPES,N}(::Type{Array{T,N}}, o::PyObject)
    try
        info = PyArray_Info(o)
        try
            copy(PyArray{T,N}(o, info)) # will check T == info.T and N == length(info.sz)
        catch
            nd = length(info.sz)
            if nd != N
                throw(ArgumentError("cannot convert $(nd)d array to $(N)d"))
            end
            return py2array(T, Array(pyany_toany(T), info.sz...), o, 1, 1)
        end
    catch
        A = py2array(T, o)
        if ndims(A) != N
            throw(ArgumentError("cannot convert $(ndims(A))d array to $(N)d"))
        end
        A
    end
end

function convert(::Type{Array{PyObject}}, o::PyObject)
    map(pyincref, convert(Array{PyPtr}, o))
end

function convert(::Type{Array{PyObject,1}}, o::PyObject)
    map(pyincref, convert(Array{PyPtr, 1}, o))
end

function convert{N}(::Type{Array{PyObject,N}}, o::PyObject)
    map(pyincref, convert(Array{PyPtr, N}, o))
end

#########################################################################

1	# Julia wrappers around the NumPy API, as part of the PyCall package
2
3	#########################################################################
4	# Initialization (UGLY)
5
6	# Linking NumPy's C API from Julia requires some serious hackery,
7	# because NumPy does not export its symbols in the usual way for
8	# shared libraries. Instead, it provides a Python variable
9	# numpy.core.multiarray._ARRAY_API that points to a lookup table of
10	# pointers to the API functions and global variables. Moreover, the
11	# meaning of this table, along with a lot of other important
12	# constants, is defined in a C header file which changes between NumPy
13	# versions, so we need to do some regex parsing of this header file in
14	# order to extract the necessary information to call NumPy. Ugly and
15	# mildly insane, but I don't see much alternative (at least to do this
16	# purely in Julia).
17	#
18	# The result of npy_api_initialize, below, is to produce the following
19	# tables of API pointers:
20	npy_api = Dict{Symbol, Ptr{Void}}()
21
22	# type alias to shorten type decorations (needed for JIT) of our table
23	typealias Tnpy_api Dict{Symbol, Ptr{Void}}
24
25	# need a global to cache pyimport("numpy.core.multiarray"), in order
26	# to ensure the module is not garbage-collected as long as we are using it
27	# for the npy_api pointers.
28	npy_multiarray = PyObject()
29
30	npy_initialized = false # global to prevent multiple initializations
31
32	# Macro version of npyinitialize() to inline npy_initialized? check
33	macro npyinitialize()
34	:(npy_initialized::Bool ? nothing : npyinitialize())
35	end
36
37	function npyinitialize()
38	global npy_api	×
39	global npy_initialized	×
40	global npy_multiarray	×
41
42	if npy_initialized::Bool	×
43	return	×
44	end
45	try	×
46	npy_multiarray::PyObject = pyimport("numpy.core.multiarray")	×
47	catch e
48	error("numpy.core.multiarray required for multidimensional Array conversions - ", e)	×
49	end
50	if pyversion < v"3.0"	×
51	PyArray_API = @pychecki ccall((@pysym :PyCObject_AsVoidPtr),	×
52	Ptr{Ptr{Void}}, (PyPtr,),
53	(npy_multiarray::PyObject)["_ARRAY_API"])
54	else
55	PyArray_API = @pychecki ccall((@pysym :PyCapsule_GetPointer),	×
56	Ptr{Ptr{Void}}, (PyPtr,Ptr{Void}),
57	(npy_multiarray::PyObject)["_ARRAY_API"], C_NULL)
58	end
59
60	# directory for numpy include files to parse
61	inc = pycall(pyimport("numpy")["get_include"], AbstractString)	×
62
63	# Parse __multiarray_api.h to obtain length and meaning of PyArray_API
64	try	×
65	hdrfile = open(joinpath(inc, "numpy", "__multiarray_api.h"))	×
66	hdr = readall(hdrfile);	×
67	close(hdrfile)	×
68	catch e
69	error("could not read __multiarray_api.h to parse PyArray_API ", e)	×
70	end
71	hdr = replace(hdr, r"\\\s*\n", " "); # rm backslashed newlines	×
72	r = r"^#define\s+([A-Za-z]\w)\s+\(.\bPyArray_API\s\[\s([0-9]+)\s\]\s\)\s*$"m # regex to match #define PyFoo (... PyArray_API[nnn])	×
73	PyArray_API_length = 0	×
74	for m in eachmatch(r, hdr) # search for max index into PyArray_API	×
75	PyArray_API_length = max(PyArray_API_length, parse(Int, m.captures[2])+1)	×
76	end
77	API = pointer_to_array(PyArray_API, (PyArray_API_length,))	×
78	for m in eachmatch(r, hdr) # build npy_api table	×
79	(npy_api::Tnpy_api)[symbol(m.captures[1])] = API[parse(Int, m.captures[2])+1]	×
80	end
81	if !haskey(npy_api::Tnpy_api, :PyArray_New)	×
82	error("failure parsing NumPy PyArray_API symbol table")	×
83	end
84
85	npy_initialized::Bool = true	×
86	return	×
87	end
88
89	function npyfinalize()
90	global npy_api	×
91	global npy_initialized	×
92	global npy_multiarray	×
93
94	if npy_initialized::Bool	×
95	empty!(npy_api::Tnpy_api)	×
96	pydecref(npy_multiarray::PyObject)	×
97	npy_initialized::Bool = false	×
98	end
99	return	×
100	end
101
102	#########################################################################
103	# Hard-coded constant values, copied from numpy/ndarraytypes.h ...
104	# the values of these seem to have been stable for some time, and
105	# the NumPy developers seem to have some awareness of binary compatibility
106
107	# NPY_TYPES:
108
109	@compat begin
110	const NPY_BOOL = Int32(0)
111	const NPY_BYTE = Int32(1)
112	const NPY_UBYTE = Int32(2)
113	const NPY_SHORT = Int32(3)
114	const NPY_USHORT = Int32(4)
115	const NPY_INT = Int32(5)
116	const NPY_UINT = Int32(6)
117	const NPY_LONG = Int32(7)
118	const NPY_ULONG = Int32(8)
119	const NPY_LONGLONG = Int32(9)
120	const NPY_ULONGLONG = Int32(10)
121	const NPY_FLOAT = Int32(11)
122	const NPY_DOUBLE = Int32(12)
123	const NPY_LONGDOUBLE = Int32(13)
124	const NPY_CFLOAT = Int32(14)
125	const NPY_CDOUBLE = Int32(15)
126	const NPY_CLONGDOUBLE = Int32(16)
127	const NPY_OBJECT = Int32(17)
128	const NPY_STRING = Int32(18)
129	const NPY_UNICODE = Int32(19)
130	const NPY_VOID = Int32(20)
131
132	# NPY_ORDER:
133	const NPY_ANYORDER = Int32(-1)
134	const NPY_CORDER = Int32(0)
135	const NPY_FORTRANORDER = Int32(1)
136
137	# flags:
138	const NPY_ARRAY_C_CONTIGUOUS = Int32(1)
139	const NPY_ARRAY_F_CONTIGUOUS = Int32(2)
140	const NPY_ARRAY_ALIGNED = Int32(0x0100)
141	const NPY_ARRAY_WRITEABLE = Int32(0x0400)
142	const NPY_ARRAY_OWNDATA = Int32(0x0004)
143	const NPY_ARRAY_ENSURECOPY = Int32(0x0020)
144	const NPY_ARRAY_ENSUREARRAY = Int32(0x0040)
145	const NPY_ARRAY_FORCECAST = Int32(0x0010)
146	const NPY_ARRAY_UPDATEIFCOPY = Int32(0x1000)
147	const NPY_ARRAY_NOTSWAPPED = Int32(0x0200)
148	const NPY_ARRAY_ELEMENTSTRIDES = Int32(0x0080)
149	end
150
151	#########################################################################
152	# conversion from Julia types to NPY_TYPES constant
153
154	npy_type(::Type{Bool}) = NPY_BOOL	×
155	npy_type(::Type{Int8}) = NPY_BYTE	×
156	npy_type(::Type{Uint8}) = NPY_UBYTE	×
157	npy_type(::Type{Int16}) = NPY_SHORT	×
158	npy_type(::Type{Uint16}) = NPY_USHORT	×
159	npy_type(::Type{Int32}) = NPY_INT	×
160	npy_type(::Type{Uint32}) = NPY_UINT	×
161	npy_type(::Type{Int64}) = NPY_LONGLONG	×
162	npy_type(::Type{Uint64}) = NPY_ULONGLONG	×
163	npy_type(::Type{Float32}) = NPY_FLOAT	×
164	npy_type(::Type{Float64}) = NPY_DOUBLE	×
165	npy_type(::Type{Complex64}) = NPY_CFLOAT	×
166	npy_type(::Type{Complex128}) = NPY_CDOUBLE	×
167	npy_type(::Type{PyPtr}) = NPY_OBJECT	×
168
169	typealias NPY_TYPES Union(Bool,Int8,Uint8,Int16,Uint16,Int32,Uint32,Int64,Uint64,Float32,Float64,Complex64,Complex128,PyPtr)
170
171	# conversions from __array_interface__ type strings to supported Julia types
172	const npy_typestrs = @compat Dict( "b1"=>Bool,
173	"i1"=>Int8, "u1"=>Uint8,
174	"i2"=>Int16, "u2"=>Uint16,
175	"i4"=>Int32, "u4"=>Uint32,
176	"i8"=>Int64, "u8"=>Uint64,
177	"f4"=>Float32, "f8"=>Float64,
178	"c8"=>Complex64, "c16"=>Complex128,
179	"O$(div(WORD_SIZE,8))"=>PyPtr )
180
181	#########################################################################
182	# no-copy conversion of Julia arrays to NumPy arrays.
183
184	function PyObject{T<:NPY_TYPES}(a::StridedArray{T})
185	try	×
186	@npyinitialize	×
187	p = @pychecki ccall(npy_api[:PyArray_New], PyPtr,	×
188	(PyPtr,Cint,Ptr{Int},Cint, Ptr{Int},Ptr{T}, Cint,Cint,PyPtr),
189	npy_api[:PyArray_Type],
190	ndims(a), Int[size(a)...], npy_type(T),
191	Int[strides(a)...] * sizeof(eltype(a)), a, sizeof(eltype(a)),
192	NPY_ARRAY_ALIGNED \| NPY_ARRAY_WRITEABLE,
193	C_NULL)
194	return PyObject(p, a)	×
195	catch e
196	array2py(a) # fallback to non-NumPy version	×
197	end
198	end
199
200	#########################################################################
201	# Extract shape and other information about a NumPy array. We need
202	# to call the Python interface to do this, since the equivalent information
203	# in NumPy's C API is only available via macros (or parsing structs).
204	# [ Hopefully, this will be improved in a future NumPy version. ]
205
206	type PyArray_Info
207	T::Type
208	native::Bool # native byte order?
209	sz::Vector{Int}
210	st::Vector{Int} # strides, in multiples of bytes!
211	data::Ptr{Void}
212	readonly::Bool
213
214	function PyArray_Info(a::PyObject)
215	ai = PyDict{AbstractString,PyObject}(a["__array_interface__"])	×
216	typestr = convert(AbstractString, ai["typestr"])	×
217	T = npy_typestrs[typestr[2:end]]	×
218	datatuple = convert(@compat(Tuple{Int,Bool}), ai["data"])	×
219	sz = convert(Vector{Int}, ai["shape"])	×
220	local st	×
221	try	×
222	st = isempty(sz) ? Int[] : convert(Vector{Int}, ai["strides"])	×
223	catch
224	# default is C-order contiguous
225	st = similar(sz)
226	st[end] = sizeof(T)	×
227	for i = length(sz)-1:-1:1	×
228	st[i] = st[i+1]*sz[i+1]	×
229	end
230	end
231	return new(T,	×
232	(ENDIAN_BOM == 0x04030201 && typestr[1] == '<')
233	\|\| (ENDIAN_BOM == 0x01020304 && typestr[1] == '>')
234	\|\| typestr[1] == '\|',
235	sz, st,
236	convert(Ptr{Void}, datatuple[1]),
237	datatuple[2])
238	end
239	end
240
241	aligned(i::PyArray_Info) = # FIXME: also check pointer alignment?	×
242	all(m -> m == 0, mod(i.st, sizeof(i.T))) # strides divisible by elsize	×
243
244	# whether a contiguous array in column-major (Fortran, Julia) order
245	function f_contiguous(T::Type, sz::Vector{Int}, st::Vector{Int})
246	if prod(sz) == 1	×
247	return true	×
248	end
249	if st[1] != sizeof(T)	×
250	return false	×
251	end
252	for j = 2:length(st)	×
253	if st[j] != st[j-1] * sz[j-1]	×
254	return false	×
255	end
256	end
257	return true	×
258	end
259
260	f_contiguous(i::PyArray_Info) = f_contiguous(i.T, i.sz, i.st)	×
261	c_contiguous(i::PyArray_Info) = f_contiguous(i.T, flipdim(i.sz,1), flipdim(i.st,1))	×
262
263	#########################################################################
264	# PyArray: no-copy wrapper around NumPy ndarray
265	#
266	# Hopefully, in the future this can be a subclass of StridedArray (see
267	# Julia issue #2345), which will allow it to be used with most Julia
268	# functions, but that is not possible at the moment. So, to use this
269	# with Julia linalg functions etcetera a copy is still required.
270
271	type PyArray{T,N} <: AbstractArray{T,N}
272	o::PyObject
273	info::PyArray_Info
274	dims::Dims
275	st::Vector{Int}
276	f_contig::Bool
277	c_contig::Bool
278	data::Ptr{T}
279
280	function PyArray(o::PyObject, info::PyArray_Info)
281	if !aligned(info)	×
282	throw(ArgumentError("only NPY_ARRAY_ALIGNED arrays are supported"))	×
283	elseif !info.native	×
284	throw(ArgumentError("only native byte-order arrays are supported"))	×
285	elseif info.T != T	×
286	throw(ArgumentError("inconsistent type in PyArray constructor"))	×
287	elseif length(info.sz) != N \|\| length(info.st) != N	×
288	throw(ArgumentError("inconsistent ndims in PyArray constructor"))	×
289	end
290	return new(o, info, tuple(info.sz...), div(info.st, sizeof(T)),	×
291	f_contiguous(info), c_contiguous(info),
292	convert(Ptr{T}, info.data))
293	end
294	end
295
296	function PyArray(o::PyObject)
297	info = PyArray_Info(o)	×
298	return PyArray{info.T, length(info.sz)}(o, info)	×
299	end
300
301	size(a::PyArray) = a.dims	×
302	ndims{T,N}(a::PyArray{T,N}) = N	×
303
304	similar(a::PyArray, T, dims::Dims) = Array(T, dims)	×
305
306	function copy{T,N}(a::PyArray{T,N})
307	if N > 1 && a.c_contig # equivalent to f_contig with reversed dims	×
308	B = pointer_to_array(a.data, ntuple(N, n -> a.dims[N - n + 1]))	×
309	return N == 2 ? transpose(B) : permutedims(B, (N:-1:1))	×
310	end
311	A = Array(T, a.dims)	×
312	if a.f_contig	×
313	ccall(:memcpy, Void, (Ptr{T}, Ptr{T}, Int), A, a, sizeof(T)*length(a))	×
314	return A	×
315	else
316	return copy!(A, a)	×
317	end
318	end
319
320	# TODO: need to do bounds-checking of these indices!
321
322	getindex{T}(a::PyArray{T,0}) = unsafe_load(a.data)	×
323	getindex{T}(a::PyArray{T,1}, i::Integer) = unsafe_load(a.data, 1 + (i-1)*a.st[1])	×
324
325	getindex{T}(a::PyArray{T,2}, i::Integer, j::Integer) =	×
326	unsafe_load(a.data, 1 + (i-1)a.st[1] + (j-1)a.st[2])
327
328	function getindex(a::PyArray, i::Integer)
329	if a.f_contig	×
330	return unsafe_load(a.data, i)	×
331	else
332	return a[ind2sub(a.dims, i)...]	×
333	end
334	end
335
336	function getindex(a::PyArray, is::Integer...)
337	index = 1	×
338	n = min(length(is),length(a.st))	×
339	for i = 1:n	×
340	index += (is[i]-1)*a.st[i]	×
341	end
342	for i = n+1:length(is)	×
343	if is[i] != 1	×
344	throw(BoundsError())	×
345	end
346	end
347	unsafe_load(a.data, index)	×
348	end
349
350	function writeok_assign(a::PyArray, v, i::Integer)
351	if a.info.readonly	×
352	throw(ArgumentError("read-only PyArray"))	×
353	else
354	unsafe_store!(a.data, v, i)	×
355	end
356	return a	×
357	end
358
359	setindex!{T}(a::PyArray{T,0}, v) = writeok_assign(a, v, 1)	×
360	setindex!{T}(a::PyArray{T,1}, v, i::Integer) = writeok_assign(a, v, 1 + (i-1)*a.st[1])	×
361
362	setindex!{T}(a::PyArray{T,2}, v, i::Integer, j::Integer) =	×
363	writeok_assign(a, v, 1 + (i-1)a.st[1] + (j-1)a.st[2])
364
365	function setindex!(a::PyArray, v, i::Integer)
366	if a.f_contig	×
367	return writeok_assign(a, v, i)	×
368	else
369	return setindex!(a, v, ind2sub(a.dims, i)...)	×
370	end
371	end
372
373	function setindex!(a::PyArray, v, is::Integer...)
374	index = 1	×
375	n = min(length(is),length(a.st))	×
376	for i = 1:n	×
377	index += (is[i]-1)*a.st[i]	×
378	end
379	for i = n+1:length(is)	×
380	if is[i] != 1	×
381	throw(BoundsError())	×
382	end
383	end
384	writeok_assign(a, v, index)	×
385	end
386
387	stride(a::PyArray, i::Integer) = a.st[i]	×
388
389	if VERSION < v"0.4.0-dev+3710"
390	convert{T}(::Type{Ptr{T}}, a::PyArray{T}) = a.data	×
391	else
392	Base.unsafe_convert{T}(::Type{Ptr{T}}, a::PyArray{T}) = a.data	×
393	end
394
395	pointer(a::PyArray, i::Int) = pointer(a, ind2sub(a.dims, i))	×
396
397	function pointer{T}(a::PyArray{T}, is::@compat Tuple{Vararg{Int}})
398	offset = 0	×
399	for i = 1:length(is)	×
400	offset += (is[i]-1)*a.st[i]	×
401	end
402	return a.data + offset*sizeof(T)	×
403	end
404
405	summary{T}(a::PyArray{T}) = string(Base.dims2string(size(a)), " ",	×
406	string(T), " PyArray")
407
408	#########################################################################
409	# PyArray <-> PyObject conversions
410
411	PyObject(a::PyArray) = a.o	×
412
413	convert(::Type{PyArray}, o::PyObject) = PyArray(o)	×
414
415	function convert{T<:NPY_TYPES}(::Type{Array{T, 1}}, o::PyObject)
416	try	×
417	copy(PyArray{T, 1}(o, PyArray_Info(o))) # will check T and N vs. info	×
418	catch
419	len = @pycheckzi ccall((@pysym :PySequence_Size), Int, (PyPtr,), o)
420	A = Array(pyany_toany(T), len)	×
421	py2array(T, A, o, 1, 1)	×
422	end
423	end
424
425	function convert{T<:NPY_TYPES}(::Type{Array{T}}, o::PyObject)
426	try	×
427	info = PyArray_Info(o)	×
428	try	×
429	copy(PyArray{T, length(info.sz)}(o, info)) # will check T == info.T	×
430	catch
431	return py2array(T, Array(pyany_toany(T), info.sz...), o, 1, 1)
432	end
433	catch
434	py2array(T, o)
435	end
436	end
437
438	function convert{T<:NPY_TYPES,N}(::Type{Array{T,N}}, o::PyObject)
439	try	×
440	info = PyArray_Info(o)	×
441	try	×
442	copy(PyArray{T,N}(o, info)) # will check T == info.T and N == length(info.sz)	×
443	catch
444	nd = length(info.sz)
445	if nd != N	×
446	throw(ArgumentError("cannot convert $(nd)d array to $(N)d"))	×
447	end
448	return py2array(T, Array(pyany_toany(T), info.sz...), o, 1, 1)	×
449	end
450	catch
451	A = py2array(T, o)
452	if ndims(A) != N	×
453	throw(ArgumentError("cannot convert $(ndims(A))d array to $(N)d"))	×
454	end
455	A	×
456	end
457	end
458
459	function convert(::Type{Array{PyObject}}, o::PyObject)
460	map(pyincref, convert(Array{PyPtr}, o))	×
461	end
462
463	function convert(::Type{Array{PyObject,1}}, o::PyObject)
464	map(pyincref, convert(Array{PyPtr, 1}, o))	×
465	end
466
467	function convert{N}(::Type{Array{PyObject,N}}, o::PyObject)
468	map(pyincref, convert(Array{PyPtr, N}, o))	×
469	end
470
471	#########################################################################

stevengj / PyCall.jl / 144

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous