diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index abf7a10..9218f3e 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -21,7 +21,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ ubuntu-20.04, ubuntu-22.04, windows-latest, macos-latest ]
-        python: [ "3.8", "3.9", "3.10", "3.11", "3.12" ]
+        python: [ "3.9", "3.10", "3.11", "3.12" ]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index 53324fd..91950b4 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -18,5 +18,5 @@ jobs:
     - name: Setup Python
       uses: actions/setup-python@v4
       with:
-        python-version: "3.8"
+        python-version: "3.9"
     - uses: pre-commit/action@v2.0.3
diff --git a/.github/workflows/setup.yml b/.github/workflows/setup.yml
index a799029..323a514 100644
--- a/.github/workflows/setup.yml
+++ b/.github/workflows/setup.yml
@@ -22,7 +22,7 @@ jobs:
         # Disable MacOS testing because it's being dumb
         # os: [ ubuntu-20.04, ubuntu-22.04, windows-latest, macos-latest ]
         os: [ ubuntu-20.04, ubuntu-22.04, windows-latest ]
-        python: [ "3.8", "3.9", "3.10", "3.11", "3.12" ]
+        python: [ "3.9", "3.10", "3.11", "3.12" ]
     runs-on: ${{ matrix.os }}
     steps:
       - name: Install MSBuild
diff --git a/.github/workflows/wheel.yml b/.github/workflows/wheel.yml
index 9078380..e1ebc3d 100644
--- a/.github/workflows/wheel.yml
+++ b/.github/workflows/wheel.yml
@@ -21,7 +21,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ ubuntu-20.04, ubuntu-22.04, windows-latest, macos-latest ]
-        python: [ "3.8", "3.9", "3.10", "3.11", "3.12" ]
+        python: [ "3.9", "3.10", "3.11", "3.12" ]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 317e977..4816532 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,10 +1,10 @@
 # Contributing
 
 There are several ways to contribute to Eigency!
-- Submit issue/bug reports [here](https://github.com/wouterboomsma/eigency/issues),
-or try to fix the problem yourself and then [submit a pull request](https://github.com/wouterboomsma/eigency/pulls).
-- Request features or ask questions [here](https://github.com/wouterboomsma/eigency/issues).
-- Browse [the source code](https://github.com/wouterboomsma/eigency) and see if anything looks out of place - let us know!
+- Submit issue/bug reports [here](https://github.com/eigency-org/eigency/issues),
+or try to fix the problem yourself and then [submit a pull request](https://github.com/eigency-org/eigency/pulls).
+- Request features or ask questions [here](https://github.com/eigency-org/eigency/issues).
+- Browse [the source code](https://github.com/eigency-org/eigency) and see if anything looks out of place - let us know!
 
 ## Getting Started
 
@@ -13,7 +13,7 @@ However, the source code and tests do successfully compile on `Windows` with MSV
 
 Clone the upstream Git repository to your local computer:
 ```bash
-git clone git@github.com:wouterboomsma/eigency.git
+git clone git@github.com:eigency-org/eigency.git
 cd eigency
 git submodule update --init
 ```
@@ -78,7 +78,7 @@ Run `pre-commit`:
 
 The first run will take longer than subsequent runs as it sets up the isolated virtual environments for each configured tool.
 
-If all checks pass, then you're ready to [submit that pull request](https://github.com/wouterboomsma/eigency/pulls)!
+If all checks pass, then you're ready to [submit that pull request](https://github.com/eigency-org/eigency/pulls)!
 
 **Thank you for your contribution!**
 
diff --git a/README.md b/README.md
index 78faf5d..aa1d17f 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
 # Eigency
 
 [![PyPI version](https://badge.fury.io/py/eigency.svg)](https://badge.fury.io/py/eigency)
-[![PEP 517](https://github.com/wouterboomsma/eigency/actions/workflows/build.yml/badge.svg)](https://github.com/wouterboomsma/eigency/actions/workflows/build.yml)
-[![pip wheel](https://github.com/wouterboomsma/eigency/actions/workflows/wheel.yml/badge.svg)](https://github.com/wouterboomsma/eigency/actions/workflows/wheel.yml)
-[![setup.py](https://github.com/wouterboomsma/eigency/actions/workflows/setup.yml/badge.svg)](https://github.com/wouterboomsma/eigency/actions/workflows/setup.yml)
-[![pre-commit](https://github.com/wouterboomsma/eigency/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/wouterboomsma/eigency/actions/workflows/pre-commit.yml)
+[![PEP 517](https://github.com/eigency-org/eigency/actions/workflows/build.yml/badge.svg)](https://github.com/eigency-org/eigency/actions/workflows/build.yml)
+[![pip wheel](https://github.com/eigency-org/eigency/actions/workflows/wheel.yml/badge.svg)](https://github.com/eigency-org/eigency/actions/workflows/wheel.yml)
+[![setup.py](https://github.com/eigency-org/eigency/actions/workflows/setup.yml/badge.svg)](https://github.com/eigency-org/eigency/actions/workflows/setup.yml)
+[![pre-commit](https://github.com/eigency-org/eigency/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/eigency-org/eigency/actions/workflows/pre-commit.yml)
 
 Eigency is a Cython interface between Numpy arrays and Matrix/Array
 objects from the Eigen C++ library. It is intended to simplify the
@@ -37,7 +37,7 @@ python -m pip install --upgrade pip
 ## Contributing
 
 For instructions on building and/or packaging Eigency from source,
-see the contributing guide [here](https://github.com/wouterboomsma/eigency/blob/master/CONTRIBUTING.md).
+see the contributing guide [here](https://github.com/eigency-org/eigency/blob/master/CONTRIBUTING.md).
 
 ## Usage
 
diff --git a/eigency/__init__.py b/eigency/__init__.py
index d1d76c4..64eced0 100644
--- a/eigency/__init__.py
+++ b/eigency/__init__.py
@@ -1,9 +1,9 @@
 import os.path
+from importlib.resources import as_file, files
 
 import numpy as np
-from pkg_resources import resource_filename
 
-__eigen_dir__ = resource_filename(__name__, "eigen")
+__eigen_dir__ = (files(__name__) / "eigen").__str__()
 
 
 def get_includes(include_eigen=True):
diff --git a/eigency/conversions.pxd b/eigency/conversions.pxd
index caae863..213c488 100644
--- a/eigency/conversions.pxd
+++ b/eigency/conversions.pxd
@@ -1,6 +1,7 @@
 cimport numpy as np
 
 
+# Array with limit 2D
 cdef api np.ndarray[long double, ndim=2] ndarray_long_double()
 cdef api np.ndarray[long double, ndim=2] ndarray_long_double_C(long double *data, long rows, long cols, long outer_stride, long inner_stride)
 cdef api np.ndarray[long double, ndim=2] ndarray_long_double_F(long double *data, long rows, long cols, long outer_stride, long inner_stride)
@@ -19,12 +20,24 @@ cdef api np.ndarray[float, ndim=2] ndarray_float_F(float *data, long rows, long
 cdef api np.ndarray[float, ndim=2] ndarray_copy_float_C(const float *data, long rows, long cols, long outer_stride, long inner_stride)
 cdef api np.ndarray[float, ndim=2] ndarray_copy_float_F(const float *data, long rows, long cols, long outer_stride, long inner_stride)
 
+cdef api np.ndarray[long long, ndim=2] ndarray_long_long()
+cdef api np.ndarray[long long, ndim=2] ndarray_long_long_C(long long *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[long long, ndim=2] ndarray_long_long_F(long long *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[long long, ndim=2] ndarray_copy_long_long_C(const long long *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[long long, ndim=2] ndarray_copy_long_long_F(const long long *data, long rows, long cols, long outer_stride, long inner_stride)
+
 cdef api np.ndarray[long, ndim=2] ndarray_long()
 cdef api np.ndarray[long, ndim=2] ndarray_long_C(long *data, long rows, long cols, long outer_stride, long inner_stride)
 cdef api np.ndarray[long, ndim=2] ndarray_long_F(long *data, long rows, long cols, long outer_stride, long inner_stride)
 cdef api np.ndarray[long, ndim=2] ndarray_copy_long_C(const long *data, long rows, long cols, long outer_stride, long inner_stride)
 cdef api np.ndarray[long, ndim=2] ndarray_copy_long_F(const long *data, long rows, long cols, long outer_stride, long inner_stride)
 
+cdef api np.ndarray[unsigned long long, ndim=2] ndarray_ulong_long()
+cdef api np.ndarray[unsigned long long, ndim=2] ndarray_ulong_long_C(unsigned long long *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[unsigned long long, ndim=2] ndarray_ulong_long_F(unsigned long long *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[unsigned long long, ndim=2] ndarray_copy_ulong_long_C(const unsigned long long *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[unsigned long long, ndim=2] ndarray_copy_ulong_long_F(const unsigned long long *data, long rows, long cols, long outer_stride, long inner_stride)
+
 cdef api np.ndarray[unsigned long, ndim=2] ndarray_ulong()
 cdef api np.ndarray[unsigned long, ndim=2] ndarray_ulong_C(unsigned long *data, long rows, long cols, long outer_stride, long inner_stride)
 cdef api np.ndarray[unsigned long, ndim=2] ndarray_ulong_F(unsigned long *data, long rows, long cols, long outer_stride, long inner_stride)
@@ -67,20 +80,20 @@ cdef api np.ndarray[unsigned char, ndim=2] ndarray_uchar_F(unsigned char *data,
 cdef api np.ndarray[unsigned char, ndim=2] ndarray_copy_uchar_C(const unsigned char *data, long rows, long cols, long outer_stride, long inner_stride)
 cdef api np.ndarray[unsigned char, ndim=2] ndarray_copy_uchar_F(const unsigned char *data, long rows, long cols, long outer_stride, long inner_stride)
 
-cdef api np.ndarray[np.npy_clongdouble, ndim=2] ndarray_complex_long_double()
-cdef api np.ndarray[np.npy_clongdouble, ndim=2] ndarray_complex_long_double_C(np.npy_clongdouble *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.npy_clongdouble, ndim=2] ndarray_complex_long_double_F(np.npy_clongdouble *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.npy_clongdouble, ndim=2] ndarray_copy_complex_long_double_C(const np.npy_clongdouble *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.npy_clongdouble, ndim=2] ndarray_copy_complex_long_double_F(const np.npy_clongdouble *data, long rows, long cols, long outer_stride, long inner_stride)
-
-cdef api np.ndarray[np.complex128_t, ndim=2] ndarray_complex_double()
-cdef api np.ndarray[np.complex128_t, ndim=2] ndarray_complex_double_C(np.complex128_t *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.complex128_t, ndim=2] ndarray_complex_double_F(np.complex128_t *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.complex128_t, ndim=2] ndarray_copy_complex_double_C(const np.complex128_t *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.complex128_t, ndim=2] ndarray_copy_complex_double_F(const np.complex128_t *data, long rows, long cols, long outer_stride, long inner_stride)
-
-cdef api np.ndarray[np.complex64_t, ndim=2] ndarray_complex_float()
-cdef api np.ndarray[np.complex64_t, ndim=2] ndarray_complex_float_C(np.complex64_t *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.complex64_t, ndim=2] ndarray_complex_float_F(np.complex64_t *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.complex64_t, ndim=2] ndarray_copy_complex_float_C(const np.complex64_t *data, long rows, long cols, long outer_stride, long inner_stride)
-cdef api np.ndarray[np.complex64_t, ndim=2] ndarray_copy_complex_float_F(const np.complex64_t *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[long double complex, ndim=2] ndarray_complex_long_double()
+cdef api np.ndarray[long double complex, ndim=2] ndarray_complex_long_double_C(long double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[long double complex, ndim=2] ndarray_complex_long_double_F(long double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[long double complex, ndim=2] ndarray_copy_complex_long_double_C(const long double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[long double complex, ndim=2] ndarray_copy_complex_long_double_F(const long double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+
+cdef api np.ndarray[double complex, ndim=2] ndarray_complex_double()
+cdef api np.ndarray[double complex, ndim=2] ndarray_complex_double_C(double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[double complex, ndim=2] ndarray_complex_double_F(double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[double complex, ndim=2] ndarray_copy_complex_double_C(const double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[double complex, ndim=2] ndarray_copy_complex_double_F(const double complex *data, long rows, long cols, long outer_stride, long inner_stride)
+
+cdef api np.ndarray[float complex, ndim=2] ndarray_complex_float()
+cdef api np.ndarray[float complex, ndim=2] ndarray_complex_float_C(float complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[float complex, ndim=2] ndarray_complex_float_F(float complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[float complex, ndim=2] ndarray_copy_complex_float_C(const float complex *data, long rows, long cols, long outer_stride, long inner_stride)
+cdef api np.ndarray[float complex, ndim=2] ndarray_copy_complex_float_F(const float complex *data, long rows, long cols, long outer_stride, long inner_stride)
diff --git a/eigency/conversions.pyx b/eigency/conversions.pyx
index d9eb433..8435469 100644
--- a/eigency/conversions.pyx
+++ b/eigency/conversions.pyx
@@ -1,77 +1,79 @@
 cimport cython
+cimport numpy as np
 
 import numpy as np
 from numpy.lib.stride_tricks import as_strided
 
+# Array with limit 2D
 #
-# long double
+# double
 #
 
 @cython.boundscheck(False)
-cdef np.ndarray[long double, ndim=2] ndarray_long_double():
-    return np.empty((0,0), dtype='longdouble')
+cdef np.ndarray[double, ndim=2] ndarray_double():
+    return np.empty((0,0), dtype='double')
 
 @cython.boundscheck(False)
-cdef np.ndarray[long double, ndim=2] ndarray_long_double_C(long double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef long double[:,:] mem_view = <long double[:rows,:cols]>data
-    dtype = 'longdouble'
+cdef np.ndarray[double, ndim=2] ndarray_double_C(double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double[:,:] mem_view = <double[:rows,:cols]>data
+    dtype = 'double'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[long double, ndim=2] ndarray_long_double_F(long double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef long double[::1,:] mem_view = <long double[:rows:1,:cols]>data
-    dtype = 'longdouble'
+cdef np.ndarray[double, ndim=2] ndarray_double_F(double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double[::1,:] mem_view = <double[:rows:1,:cols]>data
+    dtype = 'double'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[long double, ndim=2] ndarray_copy_long_double_C(const long double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef long double[:,:] mem_view = <long double[:rows,:cols]>data
-    dtype = 'longdouble'
+cdef np.ndarray[double, ndim=2] ndarray_copy_double_C(const double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double[:,:] mem_view = <double[:rows,:cols]>data
+    dtype = 'double'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 @cython.boundscheck(False)
-cdef np.ndarray[long double, ndim=2] ndarray_copy_long_double_F(const long double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef long double[::1,:] mem_view = <long double[:rows:1,:cols]>data
-    dtype = 'longdouble'
+cdef np.ndarray[double, ndim=2] ndarray_copy_double_F(const double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double[::1,:] mem_view = <double[:rows:1,:cols]>data
+    dtype = 'double'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 #
-# double
+# long double
 #
 
 @cython.boundscheck(False)
-cdef np.ndarray[double, ndim=2] ndarray_double():
-    return np.empty((0,0), dtype='double')
+cdef np.ndarray[long double, ndim=2] ndarray_long_double():
+    return np.empty((0,0), dtype='longdouble')
 
 @cython.boundscheck(False)
-cdef np.ndarray[double, ndim=2] ndarray_double_C(double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef double[:,:] mem_view = <double[:rows,:cols]>data
-    dtype = 'double'
+cdef np.ndarray[long double, ndim=2] ndarray_long_double_C(long double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double[:,:] mem_view = <long double[:rows,:cols]>data
+    dtype = 'longdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[double, ndim=2] ndarray_double_F(double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef double[::1,:] mem_view = <double[:rows:1,:cols]>data
-    dtype = 'double'
+cdef np.ndarray[long double, ndim=2] ndarray_long_double_F(long double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double[::1,:] mem_view = <long double[:rows:1,:cols]>data
+    dtype = 'longdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[double, ndim=2] ndarray_copy_double_C(const double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef double[:,:] mem_view = <double[:rows,:cols]>data
-    dtype = 'double'
+cdef np.ndarray[long double, ndim=2] ndarray_copy_long_double_C(const long double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double[:,:] mem_view = <long double[:rows,:cols]>data
+    dtype = 'longdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 @cython.boundscheck(False)
-cdef np.ndarray[double, ndim=2] ndarray_copy_double_F(const double *data, long rows, long cols, long row_stride, long col_stride):
-    cdef double[::1,:] mem_view = <double[:rows:1,:cols]>data
-    dtype = 'double'
+cdef np.ndarray[long double, ndim=2] ndarray_copy_long_double_F(const long double *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double[::1,:] mem_view = <long double[:rows:1,:cols]>data
+    dtype = 'longdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
@@ -110,6 +112,41 @@ cdef np.ndarray[float, ndim=2] ndarray_copy_float_F(const float *data, long rows
     dtype = 'float'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
+#
+# long  long
+#
+
+@cython.boundscheck(False)
+cdef np.ndarray[ longlong, ndim=2] ndarray_long_long():
+    return np.empty((0,0), dtype='longlong')
+
+@cython.boundscheck(False)
+cdef np.ndarray[longlong, ndim=2] ndarray_long_long_C(long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long long[:,:] mem_view = <long long[:rows,:cols]>data
+    dtype = 'longlong'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
+
+@cython.boundscheck(False)
+cdef np.ndarray[longlong, ndim=2] ndarray_long_long_F(long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long long[::1,:] mem_view = <long long[:rows:1,:cols]>data
+    dtype = 'longlong'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
+
+@cython.boundscheck(False)
+cdef np.ndarray[longlong, ndim=2] ndarray_copy_long_long_C(const long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long long[:,:] mem_view = <long long[:rows,:cols]>data
+    dtype = 'longlong'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
+
+@cython.boundscheck(False)
+cdef np.ndarray[longlong, ndim=2] ndarray_copy_long_long_F(const long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long long[::1,:] mem_view = <long long[:rows:1,:cols]>data
+    dtype = 'longlong'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 #
 # long
@@ -117,33 +154,68 @@ cdef np.ndarray[float, ndim=2] ndarray_copy_float_F(const float *data, long rows
 
 @cython.boundscheck(False)
 cdef np.ndarray[long, ndim=2] ndarray_long():
-    return np.empty((0,0), dtype='int_')
+    return np.empty((0,0), dtype='long')
 
 @cython.boundscheck(False)
 cdef np.ndarray[long, ndim=2] ndarray_long_C(long *data, long rows, long cols, long row_stride, long col_stride):
     cdef long[:,:] mem_view = <long[:rows,:cols]>data
-    dtype = 'int_'
+    dtype = 'long'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
 cdef np.ndarray[long, ndim=2] ndarray_long_F(long *data, long rows, long cols, long row_stride, long col_stride):
     cdef long[::1,:] mem_view = <long[:rows:1,:cols]>data
-    dtype = 'int_'
+    dtype = 'long'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
 cdef np.ndarray[long, ndim=2] ndarray_copy_long_C(const long *data, long rows, long cols, long row_stride, long col_stride):
     cdef long[:,:] mem_view = <long[:rows,:cols]>data
-    dtype = 'int_'
+    dtype = 'long'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 @cython.boundscheck(False)
 cdef np.ndarray[long, ndim=2] ndarray_copy_long_F(const long *data, long rows, long cols, long row_stride, long col_stride):
     cdef long[::1,:] mem_view = <long[:rows:1,:cols]>data
-    dtype = 'int_'
+    dtype = 'long'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
+
+#
+# unsigned long long
+#
+@cython.boundscheck(False)
+cdef np.ndarray[unsigned long long, ndim=2] ndarray_ulong_long():
+    return np.empty((0,0), dtype='ulong')
+
+@cython.boundscheck(False)
+cdef np.ndarray[unsigned long long, ndim=2] ndarray_ulong_long_C(unsigned long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef unsigned long long[:,:] mem_view = <unsigned long long[:rows,:cols]>data
+    dtype = 'ulonglong'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
+
+@cython.boundscheck(False)
+cdef np.ndarray[unsigned long long, ndim=2] ndarray_ulong_long_F(unsigned long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef unsigned long long[::1,:] mem_view = <unsigned long long[:rows:1,:cols]>data
+    dtype = 'ulonglong'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
+
+@cython.boundscheck(False)
+cdef np.ndarray[unsigned long long, ndim=2] ndarray_copy_ulong_long_C(const unsigned long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef unsigned long long[:,:] mem_view = <unsigned long long[:rows,:cols]>data
+    dtype = 'ulonglong'
+    cdef int itemsize = np.dtype(dtype).itemsize
+    return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
+
+@cython.boundscheck(False)
+cdef np.ndarray[unsigned long long, ndim=2] ndarray_copy_ulong_long_F(const unsigned long long *data, long rows, long cols, long row_stride, long col_stride):
+    cdef unsigned long long[::1,:] mem_view = <unsigned long long[:rows:1,:cols]>data
+    dtype = 'ulonglong'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
@@ -153,33 +225,33 @@ cdef np.ndarray[long, ndim=2] ndarray_copy_long_F(const long *data, long rows, l
 
 @cython.boundscheck(False)
 cdef np.ndarray[unsigned long, ndim=2] ndarray_ulong():
-    return np.empty((0,0), dtype='uint')
+    return np.empty((0,0), dtype='ulong')
 
 @cython.boundscheck(False)
 cdef np.ndarray[unsigned long, ndim=2] ndarray_ulong_C(unsigned long *data, long rows, long cols, long row_stride, long col_stride):
     cdef unsigned long[:,:] mem_view = <unsigned long[:rows,:cols]>data
-    dtype = 'uint'
+    dtype = 'ulong'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
 cdef np.ndarray[unsigned long, ndim=2] ndarray_ulong_F(unsigned long *data, long rows, long cols, long row_stride, long col_stride):
     cdef unsigned long[::1,:] mem_view = <unsigned long[:rows:1,:cols]>data
-    dtype = 'uint'
+    dtype = 'ulong'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
 cdef np.ndarray[unsigned long, ndim=2] ndarray_copy_ulong_C(const unsigned long *data, long rows, long cols, long row_stride, long col_stride):
     cdef unsigned long[:,:] mem_view = <unsigned long[:rows,:cols]>data
-    dtype = 'uint'
+    dtype = 'ulong'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 @cython.boundscheck(False)
 cdef np.ndarray[unsigned long, ndim=2] ndarray_copy_ulong_F(const unsigned long *data, long rows, long cols, long row_stride, long col_stride):
     cdef unsigned long[::1,:] mem_view = <unsigned long[:rows:1,:cols]>data
-    dtype = 'uint'
+    dtype = 'ulong'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
@@ -400,74 +472,74 @@ cdef np.ndarray[unsigned char, ndim=2] ndarray_copy_uchar_F(const unsigned char
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 #
-# complex long double
+# complex double
 #
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.npy_clongdouble, ndim=2] ndarray_complex_long_double():
-    return np.empty((0,0), dtype='clongdouble')
+cdef np.ndarray[double complex, ndim=2] ndarray_complex_double():
+    return np.empty((0,0), dtype='complex128')
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.npy_clongdouble, ndim=2] ndarray_complex_long_double_C(np.npy_clongdouble *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.npy_clongdouble[:,:] mem_view = <np.npy_clongdouble[:rows,:cols]>data
-    dtype = 'clongdouble'
+cdef np.ndarray[double complex, ndim=2] ndarray_complex_double_C(double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double complex[:,:] mem_view = <double complex[:rows,:cols]>data
+    dtype = 'complex128'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.npy_clongdouble, ndim=2] ndarray_complex_long_double_F(np.npy_clongdouble *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.npy_clongdouble[::1,:] mem_view = <np.npy_clongdouble[:rows:1,:cols]>data
-    dtype = 'clongdouble'
+cdef np.ndarray[double complex, ndim=2] ndarray_complex_double_F(double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double complex[::1,:] mem_view = <double complex[:rows:1,:cols]>data
+    dtype = 'complex128'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.npy_clongdouble, ndim=2] ndarray_copy_complex_long_double_C(const np.npy_clongdouble *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.npy_clongdouble[:,:] mem_view = <np.npy_clongdouble[:rows,:cols]>data
-    dtype = 'clongdouble'
+cdef np.ndarray[double complex, ndim=2] ndarray_copy_complex_double_C(const double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double complex[:,:] mem_view = <double complex[:rows,:cols]>data
+    dtype = 'complex128'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.npy_clongdouble, ndim=2] ndarray_copy_complex_long_double_F(const np.npy_clongdouble *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.npy_clongdouble[::1,:] mem_view = <np.npy_clongdouble[:rows:1,:cols]>data
-    dtype = 'clongdouble'
+cdef np.ndarray[double complex, ndim=2] ndarray_copy_complex_double_F(const double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef double complex[::1,:] mem_view = <double complex[:rows:1,:cols]>data
+    dtype = 'complex128'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 #
-# complex double
+# complex long double
 #
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex128_t, ndim=2] ndarray_complex_double():
-    return np.empty((0,0), dtype='complex128')
+cdef np.ndarray[long double complex, ndim=2] ndarray_complex_long_double():
+    return np.empty((0,0), dtype='clongdouble')
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex128_t, ndim=2] ndarray_complex_double_C(np.complex128_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex128_t[:,:] mem_view = <np.complex128_t[:rows,:cols]>data
-    dtype = 'complex128'
+cdef np.ndarray[long double complex, ndim=2] ndarray_complex_long_double_C(long double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double complex[:,:] mem_view = <long double complex[:rows,:cols]>data
+    dtype = 'clongdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex128_t, ndim=2] ndarray_complex_double_F(np.complex128_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex128_t[::1,:] mem_view = <np.complex128_t[:rows:1,:cols]>data
-    dtype = 'complex128'
+cdef np.ndarray[long double complex, ndim=2] ndarray_complex_long_double_F(long double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double complex[::1,:] mem_view = <long double complex[:rows:1,:cols]>data
+    dtype = 'clongdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex128_t, ndim=2] ndarray_copy_complex_double_C(const np.complex128_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex128_t[:,:] mem_view = <np.complex128_t[:rows,:cols]>data
-    dtype = 'complex128'
+cdef np.ndarray[long double complex, ndim=2] ndarray_copy_complex_long_double_C(const long double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double complex[:,:] mem_view = <long double complex[:rows,:cols]>data
+    dtype = 'clongdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex128_t, ndim=2] ndarray_copy_complex_double_F(const np.complex128_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex128_t[::1,:] mem_view = <np.complex128_t[:rows:1,:cols]>data
-    dtype = 'complex128'
+cdef np.ndarray[long double complex, ndim=2] ndarray_copy_complex_long_double_F(const long double complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef long double complex[::1,:] mem_view = <long double complex[:rows:1,:cols]>data
+    dtype = 'clongdouble'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
@@ -476,33 +548,33 @@ cdef np.ndarray[np.complex128_t, ndim=2] ndarray_copy_complex_double_F(const np.
 #
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex64_t, ndim=2] ndarray_complex_float():
+cdef np.ndarray[float complex, ndim=2] ndarray_complex_float():
     return np.empty((0,0), dtype='complex64')
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex64_t, ndim=2] ndarray_complex_float_C(np.complex64_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex64_t[:,:] mem_view = <np.complex64_t[:rows,:cols]>data
+cdef np.ndarray[float complex, ndim=2] ndarray_complex_float_C(float complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef float complex[:,:] mem_view = <float complex[:rows,:cols]>data
     dtype = 'complex64'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex64_t, ndim=2] ndarray_complex_float_F(np.complex64_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex64_t[::1,:] mem_view = <np.complex64_t[:rows:1,:cols]>data
+cdef np.ndarray[float complex, ndim=2] ndarray_complex_float_F(float complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef float complex[::1,:] mem_view = <float complex[:rows:1,:cols]>data
     dtype = 'complex64'
     cdef int itemsize = np.dtype(dtype).itemsize
     return as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize])
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex64_t, ndim=2] ndarray_copy_complex_float_C(const np.complex64_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex64_t[:,:] mem_view = <np.complex64_t[:rows,:cols]>data
+cdef np.ndarray[float complex, ndim=2] ndarray_copy_complex_float_C(const float complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef float complex[:,:] mem_view = <float complex[:rows,:cols]>data
     dtype = 'complex64'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="C"), strides=[row_stride*itemsize, col_stride*itemsize]))
 
 @cython.boundscheck(False)
-cdef np.ndarray[np.complex64_t, ndim=2] ndarray_copy_complex_float_F(const np.complex64_t *data, long rows, long cols, long row_stride, long col_stride):
-    cdef np.complex64_t[::1,:] mem_view = <np.complex64_t[:rows:1,:cols]>data
+cdef np.ndarray[float complex, ndim=2] ndarray_copy_complex_float_F(const float complex *data, long rows, long cols, long row_stride, long col_stride):
+    cdef float complex[::1,:] mem_view = <float complex[:rows:1,:cols]>data
     dtype = 'complex64'
     cdef int itemsize = np.dtype(dtype).itemsize
     return np.copy(as_strided(np.asarray(mem_view, dtype=dtype, order="F"), strides=[row_stride*itemsize, col_stride*itemsize]))
diff --git a/eigency/eigency.h b/eigency/eigency.h
index f93e261..de1719f 100644
--- a/eigency/eigency.h
+++ b/eigency/eigency.h
@@ -56,4 +56,4 @@ EIGENCY_MAKE_ARRAY_TYPEDEFS_ALL_SIZES(::std::complex<long double>, cld)
 
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/eigency/eigency_cpp.h b/eigency/eigency_cpp.h
index b90a780..cc8069c 100644
--- a/eigency/eigency_cpp.h
+++ b/eigency/eigency_cpp.h
@@ -6,12 +6,15 @@
 #define EIGENCY_CPP_H
 
 #include <Eigen/Core>
+#include <numpy/arrayobject.h>
 #include <numpy/ndarraytypes.h>
+#include <numpy/ndarrayobject.h>
 
 #include "eigency.h"
 
 typedef ::std::complex< double > __pyx_t_double_complex;
 typedef ::std::complex< float > __pyx_t_float_complex;
+typedef ::std::complex< long double > __pyx_t_long_double_complex;
 
 #include "conversions_api.h"
 
@@ -65,8 +68,12 @@ _NDAV(float, ndarray_float, ndarray_float_C, ndarray_float_F)
 _NDAC(float, ndarray_float, ndarray_copy_float_C, ndarray_copy_float_F)
 _NDAV(long, ndarray_long, ndarray_long_C, ndarray_long_F)
 _NDAC(long, ndarray_long, ndarray_copy_long_C, ndarray_copy_long_F)
+_NDAV(long long, ndarray_long_long, ndarray_long_long_C, ndarray_long_long_F)
+_NDAC(long long, ndarray_long_long, ndarray_copy_long_long_C, ndarray_copy_long_long_F)
 _NDAV(unsigned long, ndarray_ulong, ndarray_ulong_C, ndarray_ulong_F)
 _NDAC(unsigned long, ndarray_ulong, ndarray_copy_ulong_C, ndarray_copy_ulong_F)
+_NDAV(unsigned long long, ndarray_ulong_long, ndarray_ulong_long_C, ndarray_ulong_long_F)
+_NDAC(unsigned long long, ndarray_ulong_long, ndarray_copy_ulong_long_C, ndarray_copy_ulong_long_F)
 _NDAV(int, ndarray_int, ndarray_int_C, ndarray_int_F)
 _NDAC(int, ndarray_int, ndarray_copy_int_C, ndarray_copy_int_F)
 _NDAV(unsigned int, ndarray_uint, ndarray_uint_C, ndarray_uint_F)
@@ -79,8 +86,8 @@ _NDAV(signed char, ndarray_schar, ndarray_schar_C, ndarray_schar_F)
 _NDAC(signed char, ndarray_schar, ndarray_copy_schar_C, ndarray_copy_schar_F)
 _NDAV(unsigned char, ndarray_uchar, ndarray_uchar_C, ndarray_uchar_F)
 _NDAC(unsigned char, ndarray_uchar, ndarray_copy_uchar_C, ndarray_copy_uchar_F)
-_NDAV(npy_clongdouble, ndarray_complex_long_double, ndarray_complex_long_double_C, ndarray_complex_long_double_F)
-_NDAC(npy_clongdouble, ndarray_complex_long_double, ndarray_copy_complex_long_double_C, ndarray_copy_complex_long_double_F)
+_NDAV(std::complex<long double>, ndarray_complex_long_double, ndarray_complex_long_double_C, ndarray_complex_long_double_F)
+_NDAC(std::complex<long double>, ndarray_complex_long_double, ndarray_copy_complex_long_double_C, ndarray_copy_complex_long_double_F)
 _NDAV(std::complex<double>, ndarray_complex_double, ndarray_complex_double_C, ndarray_complex_double_F)
 _NDAC(std::complex<double>, ndarray_complex_double, ndarray_copy_complex_double_C, ndarray_copy_complex_double_F)
 _NDAV(std::complex<float>, ndarray_complex_float, ndarray_complex_float_C, ndarray_complex_float_F)
@@ -245,12 +252,12 @@ class FlattenedMap: public MapBase<EigencyDenseBase<Scalar, _Rows, _Cols, _Optio
     }
 
     FlattenedMap(PyArrayObject *object)
-        : Base((Scalar *)((PyArrayObject*)object)->data,
+        : Base((Scalar *) PyArray_DATA(((PyArrayObject*)object)),
         // : Base(_from_numpy<Scalar>((PyArrayObject*)object),
-               (((PyArrayObject*)object)->nd == 2) ? ((PyArrayObject*)object)->dimensions[0] : 1,
-               (((PyArrayObject*)object)->nd == 2) ? ((PyArrayObject*)object)->dimensions[1] : ((PyArrayObject*)object)->dimensions[0],
-               Eigen::Stride<_StrideOuter, _StrideInner>(_StrideOuter != Eigen::Dynamic ? _StrideOuter : (((PyArrayObject*)object)->nd == 2) ? ((PyArrayObject*)object)->dimensions[0] : 1,
-                                                         _StrideInner != Eigen::Dynamic ? _StrideInner : (((PyArrayObject*)object)->nd == 2) ? ((PyArrayObject*)object)->dimensions[1] : ((PyArrayObject*)object)->dimensions[0])),
+               (PyArray_NDIM((PyArrayObject*)object) == 2) ? PyArray_DIMS((PyArrayObject*)object)[0] : 1,
+               (PyArray_NDIM((PyArrayObject*)object) == 2) ? PyArray_DIMS((PyArrayObject*)object)[1] : PyArray_DIMS((PyArrayObject*)object)[0],
+               Eigen::Stride<_StrideOuter, _StrideInner>(_StrideOuter != Eigen::Dynamic ? _StrideOuter : (PyArray_NDIM((PyArrayObject*)object) == 2) ? PyArray_DIMS((PyArrayObject*)object)[0] : 1,
+                                                         _StrideInner != Eigen::Dynamic ? _StrideInner : (PyArray_NDIM((PyArrayObject*)object) == 2) ? PyArray_DIMS((PyArrayObject*)object)[1] : PyArray_DIMS((PyArrayObject*)object)[0])),
           object_(object) {
 
         if (((PyObject*)object != Py_None) && !PyArray_ISONESEGMENT(object))
@@ -322,21 +329,21 @@ class Map: public MapBase<MatrixType> {
           object_(NULL) {}
 
     Map(PyArrayObject *object)
-        : Base((PyObject*)object == Py_None? NULL: (Scalar *)object->data,
+        : Base((PyObject*)object == Py_None? NULL: (Scalar *)PyArray_DATA(object),
                // ROW: If array is in row-major order, transpose (see README)
                (PyObject*)object == Py_None? 0 :
                (!PyArray_IS_F_CONTIGUOUS(object)
-                ? ((object->nd == 1)
+                ? ((PyArray_NDIM(object) == 1)
                    ? 1  // ROW: If 1D row-major numpy array, set to 1 (row vector)
-                   : object->dimensions[1])
-                : object->dimensions[0]),
+                   : PyArray_DIMS(object)[1])
+                : PyArray_DIMS(object)[0]),
                // COLUMN: If array is in row-major order: transpose (see README)
                (PyObject*)object == Py_None? 0 :
                (!PyArray_IS_F_CONTIGUOUS(object)
-                ? object->dimensions[0]
-                : ((object->nd == 1)
+                ? PyArray_DIMS(object)[0]
+                : ((PyArray_NDIM(object) == 1)
                    ? 1  // COLUMN: If 1D col-major numpy array, set to length (column vector)
-                   : object->dimensions[1]))),
+                   : PyArray_DIMS(object)[1]))),
           object_(object) {
 
         if (((PyObject*)object != Py_None) && !PyArray_ISONESEGMENT(object))
@@ -390,4 +397,4 @@ class Map: public MapBase<MatrixType> {
 
 }
 
-#endif
+#endif
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index fb2921f..1c6a60d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,8 +1,46 @@
 [build-system]
 requires = [
-    "setuptools>=42",
-    "setuptools_scm",
-    "oldest-supported-numpy",
-    "Cython"
+    "setuptools>=60.0.0",
+    "setuptools_scm>=6.4.0",
+    "oldest-supported-numpy; python_version<='3.8'",
+    "numpy>=2.0.0; python_version>'3.8'",
+    "Cython>=3.0.0"
 ]
 build-backend = "setuptools.build_meta"
+
+[project]
+name = "eigency"
+dynamic = ["version"]
+description = "Cython interface between the numpy arrays and the Matrix/Array classes of the Eigen C++ library"
+
+readme  = "README.md"
+
+requires-python = ">=3.9"
+license = {file = "MIT License"}
+
+dependencies = [
+    "numpy>=1.23.5",
+]
+
+authors = [
+  {name = "Wouter Boomsma", email = "wb@di.ku.dk"},
+  {name = "Felipe Bordeu", email = "felipebordeu@gmail.com"}
+]
+maintainers = [
+  {name = "Felipe Bordeu", email = "felipebordeu@gmail.com"},
+  {name = "Wouter Boomsma", email = "wb@di.ku.dk"}
+]
+
+classifiers = [
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: C++",
+        "Programming Language :: Cython",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+    ]
+[project.urls]
+Homepage = "https://github.com/eigency-org/eigency"
diff --git a/setup.py b/setup.py
index c20ff2f..63d8d9f 100644
--- a/setup.py
+++ b/setup.py
@@ -39,12 +39,14 @@
         ["eigency/conversions" + ext],
         include_dirs=[np.get_include(), __eigen_dir__],
         language="c++",
+        define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
     ),
     Extension(
         "eigency.core",
         ["eigency/core" + ext],
         include_dirs=[np.get_include(), __eigen_dir__],
         language="c++",
+        define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
     ),
 ]
 
@@ -66,24 +68,6 @@
 
 setup(
     name=__package_name__,
-    description="Cython interface between the numpy arrays and the Matrix/Array classes of the Eigen C++ library",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    classifiers=[
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
-        "Programming Language :: C++",
-        "Programming Language :: Cython",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-        "Programming Language :: Python :: 3.12",
-    ],
-    license="MIT",
-    author="Wouter Boomsma",
-    author_email="wb@di.ku.dk",
-    url="https://github.com/wouterboomsma/eigency",
     use_scm_version=True,
     ext_modules=extensions,
     packages=find_namespace_packages(
@@ -97,6 +81,4 @@
     include_package_data=True,
     package_data={__package_name__: ["*.h", "*.pxd", "*.pyx", join(__eigen_lib_dir__, "*")] + eigen_data_files},
     exclude_package_data={__package_name__: [join(__eigen_lib_dir__, "CMakeLists.txt")]},
-    python_requires=">=3.8",
-    install_requires=["numpy"],
 )
diff --git a/tests/eigency_tests/eigency_tests.pyx b/tests/eigency_tests/eigency_tests.pyx
index 388e47a..f8ce32d 100644
--- a/tests/eigency_tests/eigency_tests.pyx
+++ b/tests/eigency_tests/eigency_tests.pyx
@@ -1,6 +1,5 @@
 # distutils: language = c++
 # distutils: sources = eigency_tests/eigency_tests_cpp.cpp
-
 from eigency.core cimport *
 
 # cimport eigency.conversions
@@ -47,7 +46,9 @@ cdef extern from "eigency_tests/eigency_tests_cpp.h":
      cdef PlainObjectBase _function_type_double "function_type_double" (Map[ArrayXXd] &)
      cdef PlainObjectBase _function_type_float "function_type_float" (Map[ArrayXXf] &)
      cdef PlainObjectBase _function_type_long "function_type_long" (FlattenedMap[Array, long, Dynamic, Dynamic] &)
+     cdef PlainObjectBase _function_type_long_long "function_type_long_long" (FlattenedMap[Array, long long, Dynamic, Dynamic] &)
      cdef PlainObjectBase _function_type_ulong "function_type_ulong" (FlattenedMap[Array, unsigned long, Dynamic, Dynamic] &)
+     cdef PlainObjectBase _function_type_ulong_long "function_type_ulong_long" (FlattenedMap[Array, unsigned long long, Dynamic, Dynamic] &)
      cdef PlainObjectBase _function_type_int "function_type_int" (Map[ArrayXXi] &)
      cdef PlainObjectBase _function_type_uint "function_type_uint" (FlattenedMap[Array, unsigned int, Dynamic, Dynamic] &)
      cdef PlainObjectBase _function_type_short "function_type_short" (FlattenedMap[Array, short, Dynamic, Dynamic] &)
@@ -152,10 +153,18 @@ def function_type_float32(np.ndarray[np.float32_t, ndim=2] array):
 def function_type_long(np.ndarray[long, ndim=2] array):
     return ndarray(_function_type_long(FlattenedMap[Array, long, Dynamic, Dynamic](array)))
 
+# Functions with different matrix types: long long
+def function_type_long_long(np.ndarray[long  long, ndim=2] array):
+    return ndarray(_function_type_long_long(FlattenedMap[Array, longlong, Dynamic, Dynamic](array)))
+
 # Functions with different matrix types: ulong
 def function_type_ulong(np.ndarray[unsigned long, ndim=2] array):
     return ndarray(_function_type_ulong(FlattenedMap[Array, ulong, Dynamic, Dynamic](array)))
 
+# Functions with different matrix types: ulong long
+def function_type_ulong_long(np.ndarray[unsigned long long, ndim=2] array):
+    return ndarray(_function_type_ulong_long(FlattenedMap[Array, ulonglong, Dynamic, Dynamic](array)))
+
 # Functions with different matrix types: int
 def function_type_intc(np.ndarray[np.int32_t, ndim=2] array):
     return ndarray(_function_type_int(Map[ArrayXXi](array)))
diff --git a/tests/eigency_tests/eigency_tests_cpp.cpp b/tests/eigency_tests/eigency_tests_cpp.cpp
index 3193688..ad5a2b2 100644
--- a/tests/eigency_tests/eigency_tests_cpp.cpp
+++ b/tests/eigency_tests/eigency_tests_cpp.cpp
@@ -88,11 +88,22 @@ Eigen::Array<long, Eigen::Dynamic, Eigen::Dynamic> function_type_long(Eigen::Map
     return output;
 }
 
+Eigen::Array<long long, Eigen::Dynamic, Eigen::Dynamic> function_type_long_long(Eigen::Map<Eigen::Array<long long, Eigen::Dynamic, Eigen::Dynamic> > &mat) {
+    Eigen::Array<long long, Eigen::Dynamic, Eigen::Dynamic> output = mat;
+    return output;
+}
+
 Eigen::Array<unsigned long, Eigen::Dynamic, Eigen::Dynamic> function_type_ulong(Eigen::Map<Eigen::Array<unsigned long, Eigen::Dynamic, Eigen::Dynamic> > &mat) {
     Eigen::Array<unsigned long, Eigen::Dynamic, Eigen::Dynamic> output = mat;
     return output;
 }
 
+Eigen::Array<unsigned long long, Eigen::Dynamic, Eigen::Dynamic> function_type_ulong_long(Eigen::Map<Eigen::Array<unsigned long long, Eigen::Dynamic, Eigen::Dynamic> > &mat) {
+    Eigen::Array<unsigned long long, Eigen::Dynamic, Eigen::Dynamic> output = mat;
+    return output;
+}
+
+
 Eigen::ArrayXXi function_type_int(Eigen::Map<Eigen::ArrayXXi> &mat) {
     Eigen::ArrayXXi output = mat;
     return output;
diff --git a/tests/eigency_tests/eigency_tests_cpp.h b/tests/eigency_tests/eigency_tests_cpp.h
index 0d8d29e..ea6a5fd 100644
--- a/tests/eigency_tests/eigency_tests_cpp.h
+++ b/tests/eigency_tests/eigency_tests_cpp.h
@@ -41,7 +41,9 @@ CustomStrideMap &function_filter3(CustomStrideMap &);
 Eigen::ArrayXXd function_type_double(Eigen::Map<Eigen::ArrayXXd> &array);
 Eigen::ArrayXXf function_type_float(Eigen::Map<Eigen::ArrayXXf> &array);
 Eigen::Array<long, Eigen::Dynamic, Eigen::Dynamic> function_type_long(Eigen::Map<Eigen::Array<long, Eigen::Dynamic, Eigen::Dynamic> > &mat);
+Eigen::Array<long long, Eigen::Dynamic, Eigen::Dynamic> function_type_long_long(Eigen::Map<Eigen::Array<long long, Eigen::Dynamic, Eigen::Dynamic> > &mat);
 Eigen::Array<unsigned long, Eigen::Dynamic, Eigen::Dynamic> function_type_ulong(Eigen::Map<Eigen::Array<unsigned long, Eigen::Dynamic, Eigen::Dynamic> > &mat);
+Eigen::Array<unsigned long long, Eigen::Dynamic, Eigen::Dynamic> function_type_ulong_long(Eigen::Map<Eigen::Array<unsigned long long, Eigen::Dynamic, Eigen::Dynamic> > &mat);
 Eigen::ArrayXXi function_type_int(Eigen::Map<Eigen::ArrayXXi> &array);
 Eigen::Array<unsigned int, Eigen::Dynamic, Eigen::Dynamic> function_type_uint(Eigen::Map<Eigen::Array<unsigned int, Eigen::Dynamic, Eigen::Dynamic> > &array);
 Eigen::Array<short, Eigen::Dynamic, Eigen::Dynamic> function_type_short(Eigen::Map<Eigen::Array<short, Eigen::Dynamic, Eigen::Dynamic> > &mat);
diff --git a/tests/run_tests.py b/tests/run_tests.py
index 47465ef..5b69d10 100644
--- a/tests/run_tests.py
+++ b/tests/run_tests.py
@@ -161,24 +161,30 @@ def test_function_type_float32(self):
 
     def test_function_type_int(self):
         # C++ long - Note that this is the standard Python integer
+        # with numpy 1 int is 32 in numpy 2 int is 64, so we need to be more specific
         mat_in = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], order="F")
-        # # equivalent to:
-        # mat_in = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], order='F', dtype=np.int_)
-        mat_out = eigency_tests.function_type_long(mat_in)
+        if mat_in.dtype == np.dtype("long"):
+            mat_out = eigency_tests.function_type_long(mat_in)
+        else:
+            mat_out = eigency_tests.function_type_long_long(mat_in)
         assert_array_equal(mat_in, mat_out)
 
     def test_function_type_long(self):
         # C++ long - Note that this is the standard Python integer
         mat_in = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], order="F", dtype=int)
-        # # equivalent to:
-        # mat_in = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], order='F', dtype=np.int_)
-        mat_out = eigency_tests.function_type_long(mat_in)
+        if mat_in.dtype == np.dtype("long"):
+            mat_out = eigency_tests.function_type_long(mat_in)
+        else:
+            mat_out = eigency_tests.function_type_long_long(mat_in)
         assert_array_equal(mat_in, mat_out)
 
     def test_function_type_ulong(self):
         # C++ ulong
         mat_in = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], order="F", dtype=np.uint)
-        mat_out = eigency_tests.function_type_ulong(mat_in)
+        if mat_in.dtype == np.dtype("ulong"):
+            mat_out = eigency_tests.function_type_ulong(mat_in)
+        else:
+            mat_out = eigency_tests.function_type_ulong_long(mat_in)
         assert_array_equal(mat_in, mat_out)
 
     def test_function_type_intc(self):
diff --git a/tests/setup.py b/tests/setup.py
index 1bd19ce..199b014 100644
--- a/tests/setup.py
+++ b/tests/setup.py
@@ -9,6 +9,7 @@
         "eigency_tests.eigency_tests",
         ["eigency_tests/eigency_tests.pyx"],
         include_dirs=[".", "eigency_tests"] + eigency.get_includes(),
+        define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")],
     ),
 ]