From c97acf474acedb92f09cdf813e80857a7085e7cd Mon Sep 17 00:00:00 2001 From: Sylvain Arreckx Date: Wed, 2 Mar 2016 14:43:31 -0500 Subject: [PATCH] c files from last commit in develop --- .gitignore | 17 +- config/.travis.yml => .travis.yml | 0 config/.gitignore | 70 - config/setup.cpy | 211 - config/site.template.cfg | 59 - config/site.template.cython.cfg | 59 - generate_code.py | 276 - mumps/{mumps_context.cpy => mumps_context.py} | 107 +- mumps/src/cysparse_mumps.cpd | 8 - mumps/src/cysparse_mumps_INT32_COMPLEX128.pxd | 8 + ...px => cysparse_mumps_INT32_COMPLEX128.pyx} | 29 +- mumps/src/cysparse_mumps_INT32_COMPLEX64.pxd | 8 + mumps/src/cysparse_mumps_INT32_COMPLEX64.pyx | 73 + mumps/src/cysparse_mumps_INT32_FLOAT32.pxd | 8 + mumps/src/cysparse_mumps_INT32_FLOAT32.pyx | 69 + mumps/src/cysparse_mumps_INT32_FLOAT64.pxd | 8 + mumps/src/cysparse_mumps_INT32_FLOAT64.pyx | 69 + mumps/src/mumps_INT32_COMPLEX128.c | 19896 ++++++++++++++++ .../{mumps.cpd => mumps_INT32_COMPLEX128.pxd} | 63 +- .../{mumps.cpx => mumps_INT32_COMPLEX128.pyx} | 116 +- mumps/src/mumps_INT32_COMPLEX64.c | 19896 ++++++++++++++++ mumps/src/mumps_INT32_COMPLEX64.pxd | 186 + mumps/src/mumps_INT32_COMPLEX64.pyx | 947 + mumps/src/mumps_INT32_FLOAT32.c | 19896 ++++++++++++++++ mumps/src/mumps_INT32_FLOAT32.pxd | 186 + mumps/src/mumps_INT32_FLOAT32.pyx | 947 + mumps/src/mumps_INT32_FLOAT64.c | 19896 ++++++++++++++++ mumps/src/mumps_INT32_FLOAT64.pxd | 186 + mumps/src/mumps_INT32_FLOAT64.pyx | 947 + mumps/src/numpy_mumps.cpd | 13 - mumps/src/numpy_mumps_INT32_COMPLEX128.c | 6978 ++++++ mumps/src/numpy_mumps_INT32_COMPLEX128.pxd | 13 + ...s.cpx => numpy_mumps_INT32_COMPLEX128.pyx} | 10 +- mumps/src/numpy_mumps_INT32_COMPLEX64.c | 6978 ++++++ mumps/src/numpy_mumps_INT32_COMPLEX64.pxd | 13 + mumps/src/numpy_mumps_INT32_COMPLEX64.pyx | 56 + mumps/src/numpy_mumps_INT32_FLOAT32.c | 6972 ++++++ mumps/src/numpy_mumps_INT32_FLOAT32.pxd | 13 + mumps/src/numpy_mumps_INT32_FLOAT32.pyx | 56 + mumps/src/numpy_mumps_INT32_FLOAT64.c | 6972 ++++++ mumps/src/numpy_mumps_INT32_FLOAT64.pxd | 13 + mumps/src/numpy_mumps_INT32_FLOAT64.pyx | 56 + release.sh | 38 - setup.py | 294 + site.template.cfg | 2 +- tests/test_mumps_with_cysparse.cpy | 89 - tests/test_mumps_with_numpy.cpy | 82 - 47 files changed, 111787 insertions(+), 1102 deletions(-) rename config/.travis.yml => .travis.yml (100%) delete mode 100644 config/.gitignore delete mode 100644 config/setup.cpy delete mode 100644 config/site.template.cfg delete mode 100644 config/site.template.cython.cfg delete mode 100644 generate_code.py rename mumps/{mumps_context.cpy => mumps_context.py} (50%) delete mode 100644 mumps/src/cysparse_mumps.cpd create mode 100644 mumps/src/cysparse_mumps_INT32_COMPLEX128.pxd rename mumps/src/{cysparse_mumps.cpx => cysparse_mumps_INT32_COMPLEX128.pyx} (63%) create mode 100644 mumps/src/cysparse_mumps_INT32_COMPLEX64.pxd create mode 100644 mumps/src/cysparse_mumps_INT32_COMPLEX64.pyx create mode 100644 mumps/src/cysparse_mumps_INT32_FLOAT32.pxd create mode 100644 mumps/src/cysparse_mumps_INT32_FLOAT32.pyx create mode 100644 mumps/src/cysparse_mumps_INT32_FLOAT64.pxd create mode 100644 mumps/src/cysparse_mumps_INT32_FLOAT64.pyx create mode 100644 mumps/src/mumps_INT32_COMPLEX128.c rename mumps/src/{mumps.cpd => mumps_INT32_COMPLEX128.pxd} (64%) rename mumps/src/{mumps.cpx => mumps_INT32_COMPLEX128.pyx} (86%) create mode 100644 mumps/src/mumps_INT32_COMPLEX64.c create mode 100644 mumps/src/mumps_INT32_COMPLEX64.pxd create mode 100644 mumps/src/mumps_INT32_COMPLEX64.pyx create mode 100644 mumps/src/mumps_INT32_FLOAT32.c create mode 100644 mumps/src/mumps_INT32_FLOAT32.pxd create mode 100644 mumps/src/mumps_INT32_FLOAT32.pyx create mode 100644 mumps/src/mumps_INT32_FLOAT64.c create mode 100644 mumps/src/mumps_INT32_FLOAT64.pxd create mode 100644 mumps/src/mumps_INT32_FLOAT64.pyx delete mode 100644 mumps/src/numpy_mumps.cpd create mode 100644 mumps/src/numpy_mumps_INT32_COMPLEX128.c create mode 100644 mumps/src/numpy_mumps_INT32_COMPLEX128.pxd rename mumps/src/{numpy_mumps.cpx => numpy_mumps_INT32_COMPLEX128.pyx} (77%) create mode 100644 mumps/src/numpy_mumps_INT32_COMPLEX64.c create mode 100644 mumps/src/numpy_mumps_INT32_COMPLEX64.pxd create mode 100644 mumps/src/numpy_mumps_INT32_COMPLEX64.pyx create mode 100644 mumps/src/numpy_mumps_INT32_FLOAT32.c create mode 100644 mumps/src/numpy_mumps_INT32_FLOAT32.pxd create mode 100644 mumps/src/numpy_mumps_INT32_FLOAT32.pyx create mode 100644 mumps/src/numpy_mumps_INT32_FLOAT64.c create mode 100644 mumps/src/numpy_mumps_INT32_FLOAT64.pxd create mode 100644 mumps/src/numpy_mumps_INT32_FLOAT64.pyx delete mode 100644 release.sh create mode 100644 setup.py delete mode 100644 tests/test_mumps_with_cysparse.cpy delete mode 100644 tests/test_mumps_with_numpy.cpy diff --git a/.gitignore b/.gitignore index 53bc21d..b7ef101 100644 --- a/.gitignore +++ b/.gitignore @@ -5,15 +5,15 @@ site.cfg __pycache__/ *.py[cod] +config +generate_code.py +release.sh + # C extensions *.so - -# Generated files -*.pyx -*.pxd -setup.py -mumps/mumps_context.py -*.c +*.cpx +*.cpd +*.cpy # Distribution / packaging .Python @@ -39,6 +39,9 @@ var/ *.manifest *.spec +# OS X specific +.DS_Store + # Installer logs pip-log.txt pip-delete-this-directory.txt diff --git a/config/.travis.yml b/.travis.yml similarity index 100% rename from config/.travis.yml rename to .travis.yml diff --git a/config/.gitignore b/config/.gitignore deleted file mode 100644 index b7ef101..0000000 --- a/config/.gitignore +++ /dev/null @@ -1,70 +0,0 @@ -# configuration file -site.cfg - -# Byte-compiled / optimized / DLL files -__pycache__/ -*.py[cod] - -config -generate_code.py -release.sh - -# C extensions -*.so -*.cpx -*.cpd -*.cpy - -# Distribution / packaging -.Python -env/ -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -*.egg-info/ -.installed.cfg -*.egg - -# PyInstaller -# Usually these files are written by a python script from a template -# before PyInstaller builds the exe, so as to inject date/other infos into it. -*.manifest -*.spec - -# OS X specific -.DS_Store - -# Installer logs -pip-log.txt -pip-delete-this-directory.txt - -# Unit test / coverage reports -htmlcov/ -.tox/ -.coverage -.coverage.* -.cache -nosetests.xml -coverage.xml -*,cover - -# Translations -*.mo -*.pot - -# Django stuff: -*.log - -# Sphinx documentation -docs/_build/ - -# PyBuilder -target/ diff --git a/config/setup.cpy b/config/setup.cpy deleted file mode 100644 index 020c888..0000000 --- a/config/setup.cpy +++ /dev/null @@ -1,211 +0,0 @@ -#!/usr/bin/env python - -# The file setup.py is automatically generated -# Generate it with -# python generate_code -s - -from distutils.core import setup -from setuptools import find_packages -from distutils.extension import Extension - -import numpy as np - -import ConfigParser -import os -import copy - -from codecs import open -from os import path - -# HELPERS -#-------- -def prepare_Cython_extensions_as_C_extensions(extensions): - """ - Modify the list of sources to transform `Cython` extensions into `C` extensions. - Args: - extensions: A list of (`Cython`) `distutils` extensions. - Warning: - The extensions are changed in place. This function is not compatible with `C++` code. - Note: - Only `Cython` source files are modified into their `C` equivalent source files. Other file types are unchanged. - """ - for extension in extensions: - c_sources = list() - for source_path in extension.sources: - path, source = os.path.split(source_path) - filename, ext = os.path.splitext(source) - - if ext == '.pyx': - c_sources.append(os.path.join(path, filename + '.c')) - elif ext in ['.pxd', '.pxi']: - pass - else: - # copy source as is - c_sources.append(source_path) - - # modify extension in place - extension.sources = c_sources - -mumps_config = ConfigParser.SafeConfigParser() -mumps_config.read('site.cfg') - -version = {} -with open("mumps/version.py") as fp: - exec(fp.read(), version) -# later on we use: version['version'] - -numpy_include = np.get_include() - -# Use Cython? -use_cython = mumps_config.getboolean('CODE_GENERATION', 'use_cython') -if use_cython: - try: - from Cython.Distutils import build_ext - from Cython.Build import cythonize - except ImportError: - raise ImportError("Check '%s': Cython is not properly installed." % mumps_config_file) - -# DEFAULT -default_include_dir = mumps_config.get('DEFAULT', 'include_dirs').split(os.pathsep) -default_library_dir = mumps_config.get('DEFAULT', 'library_dirs').split(os.pathsep) - -# mumps -mumps_compiled_in_64bits = mumps_config.getboolean('MUMPS', 'mumps_compiled_in_64bits') - -# Debug mode -use_debug_symbols = mumps_config.getboolean('CODE_GENERATION', 'use_debug_symbols') - -# find user defined directories -mumps_include_dirs = mumps_config.get('MUMPS', 'include_dirs').split(os.pathsep) -if mumps_include_dirs == '': - mumps_include_dirs = default_include_dir -mumps_library_dirs = mumps_config.get('MUMPS', 'library_dirs').split(os.pathsep) -if mumps_library_dirs == '': - mumps_library_dirs = default_library_dir - -# OPTIONAL -build_cysparse_ext = False -if mumps_config.has_section('CYSPARSE'): - build_cysparse_ext = True - cysparse_rootdir = mumps_config.get('CYSPARSE', 'cysparse_rootdir').split(os.pathsep) - if cysparse_rootdir == '': - raise ValueError("You must specify where CySparse source code is" + - "located. Use `cysparse_rootdir` to specify its path.") - - -######################################################################################################################## -# EXTENSIONS -######################################################################################################################## -include_dirs = [numpy_include, '.'] - -ext_params = {} -ext_params['include_dirs'] = include_dirs -if not use_debug_symbols: - ext_params['extra_compile_args'] = ["-O2", '-std=c99', '-Wno-unused-function'] - ext_params['extra_link_args'] = [] -else: - ext_params['extra_compile_args'] = ["-g", '-std=c99', '-Wno-unused-function'] - ext_params['extra_link_args'] = ["-g"] - -context_ext_params = copy.deepcopy(ext_params) -mumps_ext = [] -{% for index_type in index_list %} - {% for element_type in type_list %} -base_ext_params_@index_type@_@element_type@ = copy.deepcopy(ext_params) -base_ext_params_@index_type@_@element_type@['include_dirs'].extend(mumps_include_dirs) -base_ext_params_@index_type@_@element_type@['library_dirs'] = mumps_library_dirs -base_ext_params_@index_type@_@element_type@['libraries'] = [] # 'scalapack', 'pord'] -base_ext_params_@index_type@_@element_type@['libraries'].append('@element_type|generic_to_mumps_type@mumps') -base_ext_params_@index_type@_@element_type@['libraries'].append('mumps_common') -base_ext_params_@index_type@_@element_type@['libraries'].append('pord') -base_ext_params_@index_type@_@element_type@['libraries'].append('mpiseq') -base_ext_params_@index_type@_@element_type@['libraries'].append('blas') -base_ext_params_@index_type@_@element_type@['libraries'].append('pthread') - -mumps_ext.append(Extension(name="mumps.src.mumps_@index_type@_@element_type@", - sources=['mumps/src/mumps_@index_type@_@element_type@.pxd', - 'mumps/src/mumps_@index_type@_@element_type@.pyx'], - **base_ext_params_@index_type@_@element_type@)) - -numpy_ext_params_@index_type@_@element_type@ = copy.deepcopy(ext_params) -numpy_ext_params_@index_type@_@element_type@['include_dirs'].extend(mumps_include_dirs) -mumps_ext.append(Extension(name="mumps.src.numpy_mumps_@index_type@_@element_type@", - sources=['mumps/src/numpy_mumps_@index_type@_@element_type@.pxd', - 'mumps/src/numpy_mumps_@index_type@_@element_type@.pyx'], - **numpy_ext_params_@index_type@_@element_type@)) - - {% endfor %} -{% endfor %} - -if build_cysparse_ext: -{% for index_type in index_list %} - {% for element_type in type_list %} - cysparse_ext_params_@index_type@_@element_type@ = copy.deepcopy(ext_params) - cysparse_ext_params_@index_type@_@element_type@['include_dirs'].extend(cysparse_rootdir) - cysparse_ext_params_@index_type@_@element_type@['include_dirs'].extend(mumps_include_dirs) - mumps_ext.append(Extension(name="mumps.src.cysparse_mumps_@index_type@_@element_type@", - sources=['mumps/src/cysparse_mumps_@index_type@_@element_type@.pxd', - 'mumps/src/cysparse_mumps_@index_type@_@element_type@.pyx'], - **cysparse_ext_params_@index_type@_@element_type@)) - - {% endfor %} -{% endfor %} - - -packages_list = ['mumps', 'mumps.src', 'tests'] - - -# PACKAGE PREPARATION FOR EXCLUSIVE C EXTENSIONS -######################################################################################################################## -# We only use the C files **without** Cython. In fact, Cython doesn't need to be installed. -if not use_cython: - prepare_Cython_extensions_as_C_extensions(mumps_ext) - -CLASSIFIERS = """\ -Development Status :: 4 - Beta -Intended Audience :: Science/Research -Intended Audience :: Developers -License :: OSI Approved -Programming Language :: Python -Programming Language :: Cython -Topic :: Software Development -Topic :: Scientific/Engineering -Operating System :: POSIX -Operating System :: Unix -Operating System :: MacOS :: MacOS X -Natural Language :: English -""" - -here = path.abspath(path.dirname(__file__)) -# Get the long description from the relevant file -with open(path.join(here, 'DESCRIPTION.rst'), encoding='utf-8') as f: - long_description = f.read() - -setup_args = { - 'name' : 'MUMPS.py', - 'version' : version['version'], - 'description' : 'A python interface to MUMPS.', - 'long_description' : long_description, - #Author details -{% raw %} - 'author' : 'Sylvain Arreckx, Dominique Orban and Nikolaj van Omme', -{% endraw %} - 'maintainer' : "Sylvain Arreckx", -{% raw %} - 'maintainer_email' : "sylvain.arreckx@gmail.com", -{% endraw %} - 'summary' : "A Cython/Python interface to the MUMPS solver.", - 'url' : "https://github.com/PythonOptimizers/MUMPS.py.git", - 'download_url' : "https://github.com/PythonOptimizers/MUMPS.py.git", - 'license' : 'LGPL', - 'classifiers' : filter(None, CLASSIFIERS.split('\n')), - 'install_requires' : ['numpy'], - 'ext_modules' : mumps_ext, - 'package_dir' : {"mumps": "mumps"}, - 'packages' : packages_list, - 'zip_safe' : False} - -if use_cython: - setup_args['cmdclass'] = {'build_ext': build_ext} - -setup(**setup_args) diff --git a/config/site.template.cfg b/config/site.template.cfg deleted file mode 100644 index b0099a4..0000000 --- a/config/site.template.cfg +++ /dev/null @@ -1,59 +0,0 @@ -# This file provides configuration information about non-Python dependencies for -# MUMPS.py. -# -# The format of the file is that of the standard library's ConfigParser module. -# -# http://www.python.org/doc/current/lib/module-ConfigParser.html -# -# library_dirs -# List of directories to add to the library search path when compiling -# extensions with this dependency. Use the character given by os.pathsep -# to separate the items in the list. On UN*X-type systems (Linux, FreeBSD, -# OS X): -# library_dirs = /usr/lib:/usr/local/lib -# On Windows: -# library_dirs = c:\mingw\lib,c:\atlas\lib -# -# include_dirs -# List of directories to add to the header file earch path. -# include_dirs = /usr/include:/usr/local/include -# -# All libraries used **must** be dynamic. - -[CODE_GENERATION] -# log file name **without** extension (by default, we use '.log') -log_name = generator -# DEBUG/INFO/WARNING/ERROR/CRITICAL -log_level = DEBUG -console_log_level = DEBUG -file_log_level = DEBUG -# 32bits/64bits -# if left blank, we use INT64_t on 64 bits platforms and INT32_t on 32 bits platforms -DEFAULT_INDEX_TYPE = -# Do you want to generate the .c files from Cython? -use_cython = false -# Use debug symbols? -use_debug_symbols = false - -# Defaults -# ======== -# The settings given here will apply to all other sections if not overridden. -# This is a good place to add general library and include directories like -# /usr/local/{lib,include} -# -[DEFAULT] -library_dirs = /usr/local/lib -include_dirs = /usr/local/include - -[MUMPS] -# are the .so compiled in 32 or 64bits? -# by default mumps compiles in 64 bits on 64 bits architecture -# unless you compile with the option -DINTSIZE64, MUMPS expects 32-bit integers by default -# false/true -mumps_compiled_in_64bits = false -library_dirs = /usr/local/lib -include_dirs = /usr/local/include - -# Optional -# [CYSPARSE] -# cysparse_rootdir = /Users/syarra/work/VirtualEnvs/nlpy_new/programs/cysparse diff --git a/config/site.template.cython.cfg b/config/site.template.cython.cfg deleted file mode 100644 index 9fea230..0000000 --- a/config/site.template.cython.cfg +++ /dev/null @@ -1,59 +0,0 @@ -# This file provides configuration information about non-Python dependencies for -# MUMPS.py. -# -# The format of the file is that of the standard library's ConfigParser module. -# -# http://www.python.org/doc/current/lib/module-ConfigParser.html -# -# library_dirs -# List of directories to add to the library search path when compiling -# extensions with this dependency. Use the character given by os.pathsep -# to separate the items in the list. On UN*X-type systems (Linux, FreeBSD, -# OS X): -# library_dirs = /usr/lib:/usr/local/lib -# On Windows: -# library_dirs = c:\mingw\lib,c:\atlas\lib -# -# include_dirs -# List of directories to add to the header file earch path. -# include_dirs = /usr/include:/usr/local/include -# -# All libraries used **must** be dynamic. - -[CODE_GENERATION] -# log file name **without** extension (by default, we use '.log') -log_name = generator -# DEBUG/INFO/WARNING/ERROR/CRITICAL -log_level = DEBUG -console_log_level = DEBUG -file_log_level = DEBUG -# 32bits/64bits -# if left blank, we use INT64_t on 64 bits platforms and INT32_t on 32 bits platforms -DEFAULT_INDEX_TYPE = -# Do you want to generate the .c files from Cython? -use_cython = true -# Use debug symbols? -use_debug_symbols = false - -# Defaults -# ======== -# The settings given here will apply to all other sections if not overridden. -# This is a good place to add general library and include directories like -# /usr/local/{lib,include} -# -[DEFAULT] -library_dirs = /usr/local/lib -include_dirs = /usr/local/include - -[MUMPS] -# are the .so compiled in 32 or 64bits? -# by default mumps compiles in 64 bits on 64 bits architecture -# unless you compile with the option -DINTSIZE64, MUMPS expects 32-bit integers by default -# false/true -mumps_compiled_in_64bits = false -library_dirs = /usr/local/Cellar/mumps/5.0.1_1/lib -include_dirs = /usr/local/Cellar/mumps/5.0.1_1/include - -# Optional -# [CYSPARSE] -# cysparse_rootdir = /Users/syarra/work/VirtualEnvs/nlpy_new/programs/cysparse diff --git a/generate_code.py b/generate_code.py deleted file mode 100644 index c186513..0000000 --- a/generate_code.py +++ /dev/null @@ -1,276 +0,0 @@ -#!/usr/bin/env python -################################################################################ -# This script generates all templated code for MUMPS.py -# It is the single one script to use before Cythonizing the MUMPS.py library. -# This script is NOT automatically called by setup.py -# -# The order of code generation is from the "inside towards the outside": -# -# - first generate the most inner code, i.e. the code that is used inside other -# code; -# - layer by layer, generate the code that only depends on already action code. -# -# We use this homemade script with the Jinja2 template engine: -# http://jinja.pocoo.org/docs/dev/ -# -################################################################################ -from cygenja.generator import Generator -from jinja2 import Environment, FileSystemLoader - -import os -import sys -import shutil -import argparse -import logging -import ConfigParser - -################################################################################ -# INIT -################################################################################ -PATH = os.path.dirname(os.path.abspath(__file__)) - - -def make_parser(): - """ - Create a comment line argument parser. - - Returns: - The command line parser. - """ - basename = os.path.basename(sys.argv[0]) - parser = argparse.ArgumentParser(description='%s: a code generator' % basename) - - parser.add_argument("-c", "--clean", help="Clean action files", - action='store_true', required=False) - parser.add_argument("-d", "--dry_run", help="Dry run: no action is taken", - action='store_true', required=False) - parser.add_argument("-f", "--force", help="Force generation no matter what", - action='store_true', required=False) - parser.add_argument("-u", "--untrack", help="Untrack files from git", - action='store_true', required=False) - parser.add_argument('dir_pattern', nargs='?', default='.', - help='Glob pattern') - parser.add_argument('file_pattern', nargs='?', default='*.*', - help='Fnmatch pattern') - return parser - -# Conditionnal code generation -# ---------------------------- -# type of platform? 32bits or 64bits? -is_64bits = sys.maxsize > 2**32 -default_index_type_str = '32bits' -if is_64bits: - default_index_type_str = '64bits' - -mumps_config = ConfigParser.SafeConfigParser() -mumps_config.read('site.cfg') - -# test if compiled lib has been compiled in 64 or 32 bits -MUMPS_INT = None -if mumps_config.getboolean('MUMPS', 'mumps_compiled_in_64bits'): - MUMPS_INT = 'INT64' -else: - MUMPS_INT = 'INT32' - -INDEX_TYPES = [MUMPS_INT] - -COMPLEX_ELEMENT_TYPES = ['COMPLEX64', 'COMPLEX128'] -REAL_ELEMENT_TYPES = ['FLOAT32', 'FLOAT64'] -ELEMENT_TYPES = COMPLEX_ELEMENT_TYPES + REAL_ELEMENT_TYPES - -GENERAL_CONTEXT = {'index_list': INDEX_TYPES, - 'type_list': ELEMENT_TYPES, - 'complex_list': COMPLEX_ELEMENT_TYPES} - - -# ACTION FUNCTION -def single_generation(): - """ - Only generate one file without any suffix. - """ - yield '', GENERAL_CONTEXT - - -def generate_following_index_and_element(): - """ - Generate files following the index and element types. - """ - for index in INDEX_TYPES: - GENERAL_CONTEXT['index'] = index - for type in ELEMENT_TYPES: - GENERAL_CONTEXT['type'] = type - yield '_%s_%s' % (index, type), GENERAL_CONTEXT - - -# JINJA2 FILTERS -def generic_to_mumps_type(generic_type): - if generic_type in ['FLOAT32']: - return 's' - elif generic_type in ['FLOAT64']: - return 'd' - elif generic_type in ['COMPLEX64']: - return 'c' - elif generic_type in ['COMPLEX128']: - return 'z' - else: - raise TypeError("Not a recognized generic type") - - -def generic_to_c_type(generic_type): - if generic_type in ['INT32']: - return 'int' - elif generic_type in ['INT64']: - return 'long' - elif generic_type in ['FLOAT32']: - return 'float' - elif generic_type in ['FLOAT64']: - return 'double' - elif generic_type in ['COMPLEX64']: - return 'float complex' - elif generic_type in ['COMPLEX128']: - return 'double complex' - else: - raise TypeError("Not a recognized generic type") - - -def generic_to_single_double_type(generic_type): - if generic_type in ['FLOAT32', 'COMPLEX64']: - return 'float32' - elif generic_type in ['FLOAT64', 'COMPLEX128']: - return 'float64' - else: - raise TypeError("Not a recognized generic type") - - -def generic_to_c_single_double_type(generic_type): - if generic_type in ['FLOAT32', 'COMPLEX64']: - return 'float' - elif generic_type in ['FLOAT64', 'COMPLEX128']: - return 'double' - else: - raise TypeError("Not a recognized generic type") - - -# JINJA 2 environment -GENERAL_ENVIRONMENT = Environment( - autoescape=False, - loader=FileSystemLoader('/'), # we use absolute filenames - trim_blocks=True, - lstrip_blocks=True, - variable_start_string='@', - variable_end_string='@') - - -# LOGGER -LOG_LEVELS = { - 'DEBUG': logging.DEBUG, - 'INFO': logging.INFO, - 'WARNING': logging.WARNING, - 'ERROR': logging.ERROR, - 'CRITICAL': logging.CRITICAL} - - -def create_logger(mumps_config): - logger_name = mumps_config.get('CODE_GENERATION', 'log_name') - if logger_name == '': - logger_name = 'mumps_generator' - - logger = logging.getLogger(logger_name) - - # levels - log_level = LOG_LEVELS[mumps_config.get('CODE_GENERATION', - 'log_level')] - console_log_level = LOG_LEVELS[mumps_config.get('CODE_GENERATION', - 'console_log_level')] - file_log_level = LOG_LEVELS[mumps_config.get('CODE_GENERATION', - 'file_log_level')] - - logger.setLevel(log_level) - - # create console handler and set logging level - ch = logging.StreamHandler() - ch.setLevel(console_log_level) - - # create file handler and set logging level - log_file_name = logger_name + '.log' - fh = logging.FileHandler(log_file_name) - fh.setLevel(file_log_level) - - # create formatter - formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') - - # add formatter to ch and fh - ch.setFormatter(formatter) - fh.setFormatter(formatter) - - # add ch and fh to logger - logger.addHandler(ch) - logger.addHandler(fh) - - logger.info('*' * 100) - logger.info('*' * 100) - logger.info("Start some action(s)") - - return logger - - -if __name__ == "__main__": - - # command line arguments - parser = make_parser() - arg_options = parser.parse_args() - - # create logger - logger = create_logger(mumps_config) - - # cygenja engine - current_directory = os.path.dirname(os.path.abspath(__file__)) - cygenja_engine = Generator(current_directory, - GENERAL_ENVIRONMENT, - logger=logger) - - # register filters - cygenja_engine.register_filter('generic_to_mumps_type', - generic_to_mumps_type) - cygenja_engine.register_filter('generic_to_c_type', - generic_to_c_type) - cygenja_engine.register_filter('generic_to_c_single_double_type', - generic_to_c_single_double_type) - cygenja_engine.register_filter('generic_to_single_double_type', - generic_to_single_double_type) - - # register extensions - cygenja_engine.register_extension('.cpy', '.py') - cygenja_engine.register_extension('.cpx', '.pyx') - cygenja_engine.register_extension('.cpd', '.pxd') - cygenja_engine.register_extension('.cpi', '.pxi') - - # register actions - cygenja_engine.register_action('config', '*.*', single_generation) - cygenja_engine.register_action('mumps', '*.*', - single_generation) - cygenja_engine.register_action('mumps/src', '*.*', - generate_following_index_and_element) - cygenja_engine.register_action('tests', '*.*', single_generation) - - # Generation - if arg_options.dry_run: - cygenja_engine.generate(arg_options.dir_pattern, - arg_options.file_pattern, - action_ch='d', - recursively=True, - force=arg_options.force) - elif arg_options.clean: - cygenja_engine.generate(arg_options.dir_pattern, - arg_options.file_pattern, - action_ch='c', - recursively=True, - force=arg_options.force) - else: - cygenja_engine.generate(arg_options.dir_pattern, - arg_options.file_pattern, - action_ch='g', - recursively=True, - force=arg_options.force) - # special case for the setup.py file - shutil.copy2(os.path.join('config', 'setup.py'), '.') diff --git a/mumps/mumps_context.cpy b/mumps/mumps_context.py similarity index 50% rename from mumps/mumps_context.cpy rename to mumps/mumps_context.py index 108fd94..7ee2112 100644 --- a/mumps/mumps_context.cpy +++ b/mumps/mumps_context.py @@ -3,40 +3,24 @@ """ import numpy as np -{% for index_type in index_list %} - {% for element_type in type_list %} -from mumps.src.numpy_mumps_@index_type@_@element_type@ import NumpyMUMPSSolver_@index_type@_@element_type@ - {% endfor %} -{% endfor %} +from mumps.src.numpy_mumps_INT32_COMPLEX64 import NumpyMUMPSSolver_INT32_COMPLEX64 +from mumps.src.numpy_mumps_INT32_COMPLEX128 import NumpyMUMPSSolver_INT32_COMPLEX128 +from mumps.src.numpy_mumps_INT32_FLOAT32 import NumpyMUMPSSolver_INT32_FLOAT32 +from mumps.src.numpy_mumps_INT32_FLOAT64 import NumpyMUMPSSolver_INT32_FLOAT64 cysparse_installed = False try: -{% for index_type in index_list %} - {% for element_type in type_list %} - from mumps.src.cysparse_mumps_@index_type@_@element_type@ import CySparseMUMPSSolver_@index_type@_@element_type@ - {% endfor %} + from mumps.src.cysparse_mumps_INT32_COMPLEX64 import CySparseMUMPSSolver_INT32_COMPLEX64 + from mumps.src.cysparse_mumps_INT32_COMPLEX128 import CySparseMUMPSSolver_INT32_COMPLEX128 + from mumps.src.cysparse_mumps_INT32_FLOAT32 import CySparseMUMPSSolver_INT32_FLOAT32 + from mumps.src.cysparse_mumps_INT32_FLOAT64 import CySparseMUMPSSolver_INT32_FLOAT64 from cysparse.sparse.ll_mat import PyLLSparseMatrix_Check from cysparse.common_types.cysparse_types import * cysparse_installed = True -{% endfor %} except: pass -allowed_types = '\titype: -{%- for index_name in index_list -%} - @index_name@ - {%- if index_name != mumps_index_list|last -%} - , - {%- endif -%} -{%- endfor -%} -\n\tdtype: -{%- for element_name in type_list -%} - @element_name@ - {%- if element_name != mumps_type_list|last -%} - , - {%- endif -%} -{%- endfor -%} -\n' +allowed_types = '\titype:INT32,\n\tdtype:COMPLEX64,COMPLEX128,FLOAT32,FLOAT64,\n' type_error_msg = 'Matrix has an index and/or element type that is incompatible with MUMPS\nAllowed types:\n%s' % allowed_types def MUMPSContext(arg1, verbose=False): @@ -82,33 +66,23 @@ def MUMPSContext(arg1, verbose=False): itype = a_row.dtype dtype = a_val.dtype -{% for index_type in index_list %} - {% if index_type == index_list |first %} - if itype == np.@index_type|lower@: - {% for element_type in type_list %} - {% if element_type == type_list |first %} - if dtype == np.@element_type|lower@: - {% else %} - elif dtype == np.@element_type|lower@: - {% endif %} - solver = NumpyMUMPSSolver_@index_type@_@element_type@(n, nnz, sym=sym, verbose=verbose) + if itype == np.int32: + if dtype == np.complex64: + solver = NumpyMUMPSSolver_INT32_COMPLEX64(n, nnz, sym=sym, verbose=verbose) solver.get_matrix_data(a_row, a_col, a_val) return solver - {% endfor %} - {% else %} - elif itype == np.@index_type|lower@: - {% for element_type in type_list %} - {% if element_type == type_list |first %} - if dtype == np.@element_type|lower@: - {% else %} - elif dtype == np.@element_type|lower@: - {% endif %} - solver = NumpyMUMPSSolver_@index_type@_@element_type@(n, nnz, sym=sym, verbose=verbose) + elif dtype == np.complex128: + solver = NumpyMUMPSSolver_INT32_COMPLEX128(n, nnz, sym=sym, verbose=verbose) + solver.get_matrix_data(a_row, a_col, a_val) + return solver + elif dtype == np.float32: + solver = NumpyMUMPSSolver_INT32_FLOAT32(n, nnz, sym=sym, verbose=verbose) + solver.get_matrix_data(a_row, a_col, a_val) + return solver + elif dtype == np.float64: + solver = NumpyMUMPSSolver_INT32_FLOAT64(n, nnz, sym=sym, verbose=verbose) solver.get_matrix_data(a_row, a_col, a_val) return solver - {% endfor %} - {% endif %} -{% endfor %} else: raise TypeError(type_error_msg) @@ -124,33 +98,22 @@ def MUMPSContext(arg1, verbose=False): sym = A.is_symmetric assert A.ncol == n -{% for index_type in index_list %} - {% if index_type == index_list |first %} - if itype == @index_type@_T: - {% for element_type in type_list %} - {% if element_type == type_list |first %} - if dtype == @element_type@_T: - {% else %} - elif dtype == @element_type@_T: - {% endif %} - solver = CySparseMUMPSSolver_@index_type@_@element_type@(n, nnz, sym=sym, verbose=verbose) + if itype == INT32_T: + if dtype == COMPLEX64_T: + solver = CySparseMUMPSSolver_INT32_COMPLEX64(n, nnz, sym=sym, verbose=verbose) solver.get_matrix_data(A) return solver - {% endfor %} - {% else %} - elif itype == @index_type@_T: - {% for element_type in type_list %} - {% if element_type == type_list |first %} - if dtype == @element_type@_T: - {% else %} - elif dtype == @element_type@_T: - {% endif %} - solver = CySparseMUMPSSolver_@index_type@_@element_type@(n, nnz, sym=sym, verbose=verbose) + elif dtype == COMPLEX128_T: + solver = CySparseMUMPSSolver_INT32_COMPLEX128(n, nnz, sym=sym, verbose=verbose) + solver.get_matrix_data(A) + return solver + elif dtype == FLOAT32_T: + solver = CySparseMUMPSSolver_INT32_FLOAT32(n, nnz, sym=sym, verbose=verbose) + solver.get_matrix_data(A) + return solver + elif dtype == FLOAT64_T: + solver = CySparseMUMPSSolver_INT32_FLOAT64(n, nnz, sym=sym, verbose=verbose) solver.get_matrix_data(A) return solver - {% endfor %} - {% endif %} -{% endfor %} else: raise TypeError(type_error_msg) - diff --git a/mumps/src/cysparse_mumps.cpd b/mumps/src/cysparse_mumps.cpd deleted file mode 100644 index 1236bd0..0000000 --- a/mumps/src/cysparse_mumps.cpd +++ /dev/null @@ -1,8 +0,0 @@ -from cysparse.sparse.ll_mat_matrices.ll_mat_@index@_t_@type@_t cimport LLSparseMatrix_@index@_t_@type@_t - -from mumps.src.mumps_@index@_@type@ cimport BaseMUMPSSolver_@index@_@type@ - -cimport numpy as cnp -cdef class CySparseMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): - cpdef get_matrix_data(self, LLSparseMatrix_@index@_t_@type@_t A) - diff --git a/mumps/src/cysparse_mumps_INT32_COMPLEX128.pxd b/mumps/src/cysparse_mumps_INT32_COMPLEX128.pxd new file mode 100644 index 0000000..6a5a3d4 --- /dev/null +++ b/mumps/src/cysparse_mumps_INT32_COMPLEX128.pxd @@ -0,0 +1,8 @@ +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_COMPLEX128_t cimport LLSparseMatrix_INT32_t_COMPLEX128_t + +from mumps.src.mumps_INT32_COMPLEX128 cimport BaseMUMPSSolver_INT32_COMPLEX128 + +cimport numpy as cnp +cdef class CySparseMUMPSSolver_INT32_COMPLEX128(BaseMUMPSSolver_INT32_COMPLEX128): + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_COMPLEX128_t A) + \ No newline at end of file diff --git a/mumps/src/cysparse_mumps.cpx b/mumps/src/cysparse_mumps_INT32_COMPLEX128.pyx similarity index 63% rename from mumps/src/cysparse_mumps.cpx rename to mumps/src/cysparse_mumps_INT32_COMPLEX128.pyx index 08f975b..b6a6388 100644 --- a/mumps/src/cysparse_mumps.cpx +++ b/mumps/src/cysparse_mumps_INT32_COMPLEX128.pyx @@ -1,10 +1,9 @@ from cysparse.common_types.cysparse_types cimport * -from cysparse.sparse.ll_mat_matrices.ll_mat_@index@_t_@type@_t cimport LLSparseMatrix_@index@_t_@type@_t +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_COMPLEX128_t cimport LLSparseMatrix_INT32_t_COMPLEX128_t -from mumps.src.mumps_@index@_@type@ cimport BaseMUMPSSolver_@index@_@type@, c_to_fortran_index_array, MUMPS_INT -{% if type in complex_list %} -from mumps.src.mumps_@index@_@type@ cimport @type|generic_to_mumps_type|upper@MUMPS_COMPLEX -{% endif %} +from mumps.src.mumps_INT32_COMPLEX128 cimport BaseMUMPSSolver_INT32_COMPLEX128, c_to_fortran_index_array, MUMPS_INT + +from mumps.src.mumps_INT32_COMPLEX128 cimport ZMUMPS_COMPLEX from cpython.mem cimport PyMem_Malloc, PyMem_Free @@ -18,11 +17,11 @@ cnp.import_array() import time -cdef class CySparseMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): +cdef class CySparseMUMPSSolver_INT32_COMPLEX128(BaseMUMPSSolver_INT32_COMPLEX128): """ MUMPS Context. - This version **only** deals with ``LLSparseMatrix_@index@_t_@type@_t`` objects. + This version **only** deals with ``LLSparseMatrix_INT32_t_COMPLEX128_t`` objects. We follow the common use of MUMPS. In particular, we use the same names for the methods of this class as their corresponding counter-parts in MUMPS. @@ -49,10 +48,10 @@ cdef class CySparseMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): PyMem_Free(self.params.jcn) PyMem_Free(self.params.a) - cpdef get_matrix_data(self, LLSparseMatrix_@index@_t_@type@_t A): + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_COMPLEX128_t A): """ Args: - A: :class:`LLSparseMatrix_@index@_t_@type@_t` object. + A: :class:`LLSparseMatrix_INT32_t_COMPLEX128_t` object. Note: we keep the same name for this method in all derived classes. """ @@ -66,13 +65,9 @@ cdef class CySparseMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): arow = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) acol = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) -{% if type in complex_list %} - a_val = <@type@_t *> PyMem_Malloc(nnz * sizeof(@type@_t)) + + a_val = PyMem_Malloc(nnz * sizeof(COMPLEX128_t)) A.fill_triplet(arow, acol, a_val) - aval = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> a_val -{% else %} - aval = <@type@_t *> PyMem_Malloc(nnz * sizeof(@type@_t)) - A.fill_triplet(arow, acol, aval) -{% endif %} + aval = a_val - self.get_data_pointers(arow, acol, aval) + self.get_data_pointers(arow, acol, aval) \ No newline at end of file diff --git a/mumps/src/cysparse_mumps_INT32_COMPLEX64.pxd b/mumps/src/cysparse_mumps_INT32_COMPLEX64.pxd new file mode 100644 index 0000000..ff62d92 --- /dev/null +++ b/mumps/src/cysparse_mumps_INT32_COMPLEX64.pxd @@ -0,0 +1,8 @@ +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_COMPLEX64_t cimport LLSparseMatrix_INT32_t_COMPLEX64_t + +from mumps.src.mumps_INT32_COMPLEX64 cimport BaseMUMPSSolver_INT32_COMPLEX64 + +cimport numpy as cnp +cdef class CySparseMUMPSSolver_INT32_COMPLEX64(BaseMUMPSSolver_INT32_COMPLEX64): + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_COMPLEX64_t A) + \ No newline at end of file diff --git a/mumps/src/cysparse_mumps_INT32_COMPLEX64.pyx b/mumps/src/cysparse_mumps_INT32_COMPLEX64.pyx new file mode 100644 index 0000000..0e05d90 --- /dev/null +++ b/mumps/src/cysparse_mumps_INT32_COMPLEX64.pyx @@ -0,0 +1,73 @@ +from cysparse.common_types.cysparse_types cimport * +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_COMPLEX64_t cimport LLSparseMatrix_INT32_t_COMPLEX64_t + +from mumps.src.mumps_INT32_COMPLEX64 cimport BaseMUMPSSolver_INT32_COMPLEX64, c_to_fortran_index_array, MUMPS_INT + +from mumps.src.mumps_INT32_COMPLEX64 cimport CMUMPS_COMPLEX + +from cpython.mem cimport PyMem_Malloc, PyMem_Free + +from libc.stdint cimport int64_t +from libc.string cimport strncpy + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + +import time + +cdef class CySparseMUMPSSolver_INT32_COMPLEX64(BaseMUMPSSolver_INT32_COMPLEX64): + """ + MUMPS Context. + + This version **only** deals with ``LLSparseMatrix_INT32_t_COMPLEX64_t`` objects. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + + """ + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + Warning: + The solver takes a "snapshot" of the matrix ``A``, i.e. the results given by the solver are only + valid for the matrix given. If the matrix ``A`` changes aferwards, the results given by the solver won't + reflect this change. + """ + pass + + def __dealloc__(self): + PyMem_Free(self.params.irn) + PyMem_Free(self.params.jcn) + PyMem_Free(self.params.a) + + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_COMPLEX64_t A): + """ + Args: + A: :class:`LLSparseMatrix_INT32_t_COMPLEX64_t` object. + + Note: we keep the same name for this method in all derived classes. + """ + assert A.ncol == A.nrow + + n = A.nrow + nnz = A.nnz + assert self.sym == A.is_symmetric + + # create i, j, val + arow = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) + acol = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) + + + a_val = PyMem_Malloc(nnz * sizeof(COMPLEX64_t)) + A.fill_triplet(arow, acol, a_val) + aval = a_val + + self.get_data_pointers(arow, acol, aval) \ No newline at end of file diff --git a/mumps/src/cysparse_mumps_INT32_FLOAT32.pxd b/mumps/src/cysparse_mumps_INT32_FLOAT32.pxd new file mode 100644 index 0000000..4f3d6d3 --- /dev/null +++ b/mumps/src/cysparse_mumps_INT32_FLOAT32.pxd @@ -0,0 +1,8 @@ +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_FLOAT32_t cimport LLSparseMatrix_INT32_t_FLOAT32_t + +from mumps.src.mumps_INT32_FLOAT32 cimport BaseMUMPSSolver_INT32_FLOAT32 + +cimport numpy as cnp +cdef class CySparseMUMPSSolver_INT32_FLOAT32(BaseMUMPSSolver_INT32_FLOAT32): + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_FLOAT32_t A) + \ No newline at end of file diff --git a/mumps/src/cysparse_mumps_INT32_FLOAT32.pyx b/mumps/src/cysparse_mumps_INT32_FLOAT32.pyx new file mode 100644 index 0000000..c92dfd8 --- /dev/null +++ b/mumps/src/cysparse_mumps_INT32_FLOAT32.pyx @@ -0,0 +1,69 @@ +from cysparse.common_types.cysparse_types cimport * +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_FLOAT32_t cimport LLSparseMatrix_INT32_t_FLOAT32_t + +from mumps.src.mumps_INT32_FLOAT32 cimport BaseMUMPSSolver_INT32_FLOAT32, c_to_fortran_index_array, MUMPS_INT + +from cpython.mem cimport PyMem_Malloc, PyMem_Free + +from libc.stdint cimport int64_t +from libc.string cimport strncpy + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + +import time + +cdef class CySparseMUMPSSolver_INT32_FLOAT32(BaseMUMPSSolver_INT32_FLOAT32): + """ + MUMPS Context. + + This version **only** deals with ``LLSparseMatrix_INT32_t_FLOAT32_t`` objects. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + + """ + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + Warning: + The solver takes a "snapshot" of the matrix ``A``, i.e. the results given by the solver are only + valid for the matrix given. If the matrix ``A`` changes aferwards, the results given by the solver won't + reflect this change. + """ + pass + + def __dealloc__(self): + PyMem_Free(self.params.irn) + PyMem_Free(self.params.jcn) + PyMem_Free(self.params.a) + + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_FLOAT32_t A): + """ + Args: + A: :class:`LLSparseMatrix_INT32_t_FLOAT32_t` object. + + Note: we keep the same name for this method in all derived classes. + """ + assert A.ncol == A.nrow + + n = A.nrow + nnz = A.nnz + assert self.sym == A.is_symmetric + + # create i, j, val + arow = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) + acol = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) + + aval = PyMem_Malloc(nnz * sizeof(FLOAT32_t)) + A.fill_triplet(arow, acol, aval) + + self.get_data_pointers(arow, acol, aval) \ No newline at end of file diff --git a/mumps/src/cysparse_mumps_INT32_FLOAT64.pxd b/mumps/src/cysparse_mumps_INT32_FLOAT64.pxd new file mode 100644 index 0000000..1a0944b --- /dev/null +++ b/mumps/src/cysparse_mumps_INT32_FLOAT64.pxd @@ -0,0 +1,8 @@ +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_FLOAT64_t cimport LLSparseMatrix_INT32_t_FLOAT64_t + +from mumps.src.mumps_INT32_FLOAT64 cimport BaseMUMPSSolver_INT32_FLOAT64 + +cimport numpy as cnp +cdef class CySparseMUMPSSolver_INT32_FLOAT64(BaseMUMPSSolver_INT32_FLOAT64): + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_FLOAT64_t A) + \ No newline at end of file diff --git a/mumps/src/cysparse_mumps_INT32_FLOAT64.pyx b/mumps/src/cysparse_mumps_INT32_FLOAT64.pyx new file mode 100644 index 0000000..2927571 --- /dev/null +++ b/mumps/src/cysparse_mumps_INT32_FLOAT64.pyx @@ -0,0 +1,69 @@ +from cysparse.common_types.cysparse_types cimport * +from cysparse.sparse.ll_mat_matrices.ll_mat_INT32_t_FLOAT64_t cimport LLSparseMatrix_INT32_t_FLOAT64_t + +from mumps.src.mumps_INT32_FLOAT64 cimport BaseMUMPSSolver_INT32_FLOAT64, c_to_fortran_index_array, MUMPS_INT + +from cpython.mem cimport PyMem_Malloc, PyMem_Free + +from libc.stdint cimport int64_t +from libc.string cimport strncpy + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + +import time + +cdef class CySparseMUMPSSolver_INT32_FLOAT64(BaseMUMPSSolver_INT32_FLOAT64): + """ + MUMPS Context. + + This version **only** deals with ``LLSparseMatrix_INT32_t_FLOAT64_t`` objects. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + + """ + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + Warning: + The solver takes a "snapshot" of the matrix ``A``, i.e. the results given by the solver are only + valid for the matrix given. If the matrix ``A`` changes aferwards, the results given by the solver won't + reflect this change. + """ + pass + + def __dealloc__(self): + PyMem_Free(self.params.irn) + PyMem_Free(self.params.jcn) + PyMem_Free(self.params.a) + + cpdef get_matrix_data(self, LLSparseMatrix_INT32_t_FLOAT64_t A): + """ + Args: + A: :class:`LLSparseMatrix_INT32_t_FLOAT64_t` object. + + Note: we keep the same name for this method in all derived classes. + """ + assert A.ncol == A.nrow + + n = A.nrow + nnz = A.nnz + assert self.sym == A.is_symmetric + + # create i, j, val + arow = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) + acol = PyMem_Malloc(nnz * sizeof(MUMPS_INT)) + + aval = PyMem_Malloc(nnz * sizeof(FLOAT64_t)) + A.fill_triplet(arow, acol, aval) + + self.get_data_pointers(arow, acol, aval) \ No newline at end of file diff --git a/mumps/src/mumps_INT32_COMPLEX128.c b/mumps/src/mumps_INT32_COMPLEX128.c new file mode 100644 index 0000000..e1ef975 --- /dev/null +++ b/mumps/src/mumps_INT32_COMPLEX128.c @@ -0,0 +1,19896 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__mumps_INT32_COMPLEX128 +#define __PYX_HAVE_API__mumps__src__mumps_INT32_COMPLEX128 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "zmumps_c.h" +#include "stdint.h" +#include "pythread.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/mumps_INT32_COMPLEX128.pyx", + "__init__.pxd", + "type.pxd", + "bool.pxd", + "complex.pxd", +}; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve; +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class zmumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":135 + * int ub + * + * cdef get_array(self, ZMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":113 + * cdef void zmumps_c(ZMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class zmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_vtab; + ZMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_COMPLEX128: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + ZMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + ZMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve { + PyObject_HEAD + PyObject *__pyx_v_kwargs; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr { + PyObject_HEAD + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *__pyx_outer_scope; + PyObject *__pyx_v_arg; +}; + + + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":245 + * + * # MUMPS HELPERS + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":274 + * self.array[key - 1] = value + * + * cdef class zmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *, ZMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":313 + * + * # MUMPS CONTEXT + * cdef class BaseMUMPSSolver_INT32_COMPLEX128: # <<<<<<<<<<<<<< + * """ + * Base MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, MUMPS_INT *, MUMPS_INT *, ZMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, ZMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, MUMPS_INT *, MUMPS_INT *, ZMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, ZMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +static CYTHON_INLINE PyObject* __Pyx_decode_bytes( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string), + start, stop, encoding, errors, decode_func); +} + +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\ + PyObject_RichCompare(op1, op2, Py_EQ) + #endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); + +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +#include + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *); +typedef struct { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject *type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname); +static int __Pyx_Coroutine_clear(PyObject *self); +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue); +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue) +#endif + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +static int __Pyx_patch_abc(void); + +#define __Pyx_Generator_USED +static PyTypeObject *__pyx_GeneratorType = 0; +#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_New(body, closure, name, qualname)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, closure, name, qualname) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(void); + +static int __Pyx_check_binary_version(void); + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self, ZMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_get_data_pointers(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, ZMUMPS_COMPLEX *__pyx_v_a_val); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mumps_call(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_solve_dense(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, ZMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_solve_sparse(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, ZMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, ZMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython.version' */ + +/* Module declarations from 'cpython.exc' */ + +/* Module declarations from 'cpython.module' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'cpython.tuple' */ + +/* Module declarations from 'cpython.list' */ + +/* Module declarations from 'cpython.sequence' */ + +/* Module declarations from 'cpython.mapping' */ + +/* Module declarations from 'cpython.iterator' */ + +/* Module declarations from 'cpython.number' */ + +/* Module declarations from 'cpython.int' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.bool' */ +static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; + +/* Module declarations from 'cpython.long' */ + +/* Module declarations from 'cpython.float' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.complex' */ +static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; + +/* Module declarations from 'cpython.string' */ + +/* Module declarations from 'cpython.unicode' */ + +/* Module declarations from 'cpython.dict' */ + +/* Module declarations from 'cpython.instance' */ + +/* Module declarations from 'cpython.function' */ + +/* Module declarations from 'cpython.method' */ + +/* Module declarations from 'cpython.weakref' */ + +/* Module declarations from 'cpython.getargs' */ + +/* Module declarations from 'cpython.pythread' */ + +/* Module declarations from 'cpython.pystate' */ + +/* Module declarations from 'cpython.cobject' */ + +/* Module declarations from 'cpython.oldbuffer' */ + +/* Module declarations from 'cpython.set' */ + +/* Module declarations from 'cpython.bytes' */ + +/* Module declarations from 'cpython.pycapsule' */ + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'libc.stdint' */ + +/* Module declarations from 'mumps.src.mumps_INT32_COMPLEX128' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr = 0; +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_c_to_fortran_index_array(MUMPS_INT *, MUMPS_INT); /*proto*/ +#define __Pyx_MODULE_NAME "mumps.src.mumps_INT32_COMPLEX128" +int __pyx_module_is_main_mumps__src__mumps_INT32_COMPLEX128 = 0; + +/* Implementation of 'mumps.src.mumps_INT32_COMPLEX128' */ +static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_IndexError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_amd[] = "amd"; +static char __pyx_k_amf[] = "amf"; +static char __pyx_k_doc[] = "__doc__"; +static char __pyx_k_get[] = "get"; +static char __pyx_k_msg[] = "msg"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_rhs[] = "rhs"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_tol[] = "tol"; +static char __pyx_k_args[] = "args"; +static char __pyx_k_auto[] = "auto"; +static char __pyx_k_copy[] = "copy"; +static char __pyx_k_init[] = "__init__"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_ndim[] = "ndim"; +static char __pyx_k_pord[] = "pord"; +static char __pyx_k_qamd[] = "qamd"; +static char __pyx_k_self[] = "self"; +static char __pyx_k_send[] = "send"; +static char __pyx_k_size[] = "size"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_time[] = "time"; +static char __pyx_k_clock[] = "clock"; +static char __pyx_k_close[] = "close"; +static char __pyx_k_dtype[] = "dtype"; +static char __pyx_k_error[] = "error"; +static char __pyx_k_infog[] = "infog"; +static char __pyx_k_metis[] = "metis"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_shape[] = "shape"; +static char __pyx_k_throw[] = "throw"; +static char __pyx_k_zeros[] = "zeros"; +static char __pyx_k_format[] = "format"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_module[] = "__module__"; +static char __pyx_k_nitref[] = "nitref"; +static char __pyx_k_scotch[] = "scotch"; +static char __pyx_k_analyze[] = "analyze"; +static char __pyx_k_genexpr[] = "genexpr"; +static char __pyx_k_prepare[] = "__prepare__"; +static char __pyx_k_rhs_val[] = "rhs_val"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ordering[] = "ordering"; +static char __pyx_k_qualname[] = "__qualname__"; +static char __pyx_k_TypeError[] = "TypeError"; +static char __pyx_k_factorize[] = "factorize"; +static char __pyx_k_metaclass[] = "__metaclass__"; +static char __pyx_k_orderings[] = "orderings"; +static char __pyx_k_pivot_tol[] = "pivot_tol"; +static char __pyx_k_IndexError[] = "IndexError"; +static char __pyx_k_MUMPSError[] = "MUMPSError"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_complex128[] = "complex128"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_refinement[] = "refinement."; +static char __pyx_k_set_silent[] = "set_silent"; +static char __pyx_k_MUMPS_error[] = "{}. (MUMPS error {})"; +static char __pyx_k_rhs_col_ptr[] = "rhs_col_ptr"; +static char __pyx_k_rhs_row_ind[] = "rhs_row_ind"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_user_defined[] = "user-defined"; +static char __pyx_k_ordering_name[] = "ordering_name"; +static char __pyx_k_asfortranarray[] = "asfortranarray"; +static char __pyx_k_error_messages[] = "error_messages"; +static char __pyx_k_SolveStatistics[] = "SolveStatistics"; +static char __pyx_k_transpose_solve[] = "transpose_solve"; +static char __pyx_k_MUMPSError___init[] = "MUMPSError.__init__"; +static char __pyx_k_Not_enough_memory[] = "Not enough memory"; +static char __pyx_k_AnalysisStatistics[] = "AnalysisStatistics"; +static char __pyx_k_solve_locals_genexpr[] = "solve..genexpr"; +static char __pyx_k_MUMPS_index_must_be_d[] = "MUMPS index must be <= %d"; +static char __pyx_k_mumps_mumps_statistics[] = "mumps.mumps_statistics"; +static char __pyx_k_FactorizationStatistics[] = "FactorizationStatistics"; +static char __pyx_k_MUMPS_failed_with_error[] = "MUMPS failed with error {}."; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_Matrix_is_numerically_singular[] = "Matrix is numerically singular"; +static char __pyx_k_This_is_the_base_class_for_the[] = "\nThis is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home)\n\n"; +static char __pyx_k_Matrix_is_singular_in_structure[] = "Matrix is singular in structure"; +static char __pyx_k_The_authors_of_MUMPS_would_like[] = "The authors of MUMPS would like to hear about this"; +static char __pyx_k_Users_syarra_work_VirtualEnvs_n[] = "/Users/syarra/work/VirtualEnvs/nlpy_new/programs/MUMPS.py/mumps/src/mumps_INT32_COMPLEX128.pyx"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_MUMPS_index_must_be_1_Fortran_st[] = "MUMPS index must be >= 1 (Fortran style)"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_Not_enough_memory_during_analysi[] = "Not enough memory during analysis phase"; +static char __pyx_k_Only_one_dense_rhs_is_allowed_fo[] = "Only one dense rhs is allowed for performing an iterative"; +static char __pyx_k_Right_hand_side_has_wrong_sizeAt[] = "Right hand side has wrong sizeAttempting to solve the linear system, where A is of size (%d, %d) and rhs is of size (%g)"; +static char __pyx_k_mumps_src_mumps_INT32_COMPLEX128[] = "mumps.src.mumps_INT32_COMPLEX128"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_rhs_dense_arrays_must_be_an_NumP[] = "rhs dense arrays must be an NumPy array"; +static char __pyx_k_rhs_not_given_in_the_right_forma[] = "rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_n_s_AnalysisStatistics; +static PyObject *__pyx_n_s_FactorizationStatistics; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_n_s_MUMPSError; +static PyObject *__pyx_n_s_MUMPSError___init; +static PyObject *__pyx_kp_s_MUMPS_error; +static PyObject *__pyx_kp_s_MUMPS_failed_with_error; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_d; +static PyObject *__pyx_kp_s_Matrix_is_numerically_singular; +static PyObject *__pyx_kp_s_Matrix_is_singular_in_structure; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_kp_s_Not_enough_memory; +static PyObject *__pyx_kp_s_Not_enough_memory_during_analysi; +static PyObject *__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo; +static PyObject *__pyx_kp_s_Right_hand_side_has_wrong_sizeAt; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_SolveStatistics; +static PyObject *__pyx_kp_s_The_authors_of_MUMPS_would_like; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Users_syarra_work_VirtualEnvs_n; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_amd; +static PyObject *__pyx_n_s_amf; +static PyObject *__pyx_n_s_analyze; +static PyObject *__pyx_n_s_args; +static PyObject *__pyx_n_s_asfortranarray; +static PyObject *__pyx_n_s_auto; +static PyObject *__pyx_n_s_clock; +static PyObject *__pyx_n_s_close; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_complex128; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_error_messages; +static PyObject *__pyx_n_s_factorize; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_genexpr; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_infog; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_metis; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_msg; +static PyObject *__pyx_n_s_mumps_mumps_statistics; +static PyObject *__pyx_n_s_mumps_src_mumps_INT32_COMPLEX128; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_nitref; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_ordering; +static PyObject *__pyx_n_s_ordering_name; +static PyObject *__pyx_n_s_orderings; +static PyObject *__pyx_n_s_pivot_tol; +static PyObject *__pyx_n_s_pord; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_qamd; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_kp_s_refinement; +static PyObject *__pyx_n_s_rhs; +static PyObject *__pyx_n_s_rhs_col_ptr; +static PyObject *__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP; +static PyObject *__pyx_kp_s_rhs_not_given_in_the_right_forma; +static PyObject *__pyx_n_s_rhs_row_ind; +static PyObject *__pyx_n_s_rhs_val; +static PyObject *__pyx_n_s_scotch; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_n_s_send; +static PyObject *__pyx_n_s_set_silent; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_size; +static PyObject *__pyx_n_s_solve_locals_genexpr; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_throw; +static PyObject *__pyx_n_s_time; +static PyObject *__pyx_n_s_tol; +static PyObject *__pyx_n_s_transpose_solve; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_kp_s_user_defined; +static PyObject *__pyx_n_s_verbose; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128___cinit__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose); /* proto */ +static void __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2__dealloc__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8analyzed___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10factorized___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5icntl___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4info___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5infog___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_14version_number___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4cntl___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5rinfo___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rinfog___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4set_silent(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6analyze(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_ordering); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8factorize(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5solve_genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10solve(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12refine(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_float_0_01; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_5; +static PyObject *__pyx_int_6; +static PyObject *__pyx_int_7; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_int_neg_5; +static PyObject *__pyx_int_neg_6; +static PyObject *__pyx_int_neg_7; +static PyObject *__pyx_int_neg_8; +static PyObject *__pyx_int_neg_9; +static PyObject *__pyx_int_neg_10; +static PyObject *__pyx_int_neg_11; +static PyObject *__pyx_int_neg_12; +static PyObject *__pyx_int_neg_13; +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_codeobj__14; + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError_1__init__ = {"__init__", (PyCFunction)__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_infog = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_infog,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_infog)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_infog = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError___init__(__pyx_self, __pyx_v_self, __pyx_v_infog); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog) { + PyObject *__pyx_v_msg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":235 + * class MUMPSError(RuntimeError): + * def __init__(self, infog): + * self.error = infog[1] # <<<<<<<<<<<<<< + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_infog, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_error, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":237 + * self.error = infog[1] + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( # <<<<<<<<<<<<<< + * error_messages[self.error], self.error) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":238 + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) # <<<<<<<<<<<<<< + * else: + * msg = "MUMPS failed with error {}.".format(self.error) + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + goto __pyx_L3; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":240 + * error_messages[self.error], self.error) + * else: + * msg = "MUMPS failed with error {}.".format(self.error) # <<<<<<<<<<<<<< + * + * RuntimeError.__init__(self, msg) + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_failed_with_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_6) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":242 + * msg = "MUMPS failed with error {}.".format(self.error) + * + * RuntimeError.__init__(self, msg) # <<<<<<<<<<<<<< + * + * # MUMPS HELPERS + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_builtin_RuntimeError, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_self); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_msg); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":252 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array___cinit__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":260 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":261 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_2__getitem__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":267 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":269 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.mumps_int_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_4__setitem__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":272 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * cdef class zmumps_real_array: + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.mumps_int_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":281 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array___cinit__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":284 + * pass + * + * cdef get_array(self, ZMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self, ZMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":289 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":290 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":284 + * pass + * + * cdef get_array(self, ZMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_2__getitem__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":296 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":298 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.zmumps_real_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_4__setitem__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + ZMUMPS_REAL __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":301 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (ZMUMPS_REAL)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.zmumps_real_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_c_to_fortran_index_array(MUMPS_INT *__pyx_v_a, MUMPS_INT __pyx_v_a_size) { + MUMPS_INT __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + MUMPS_INT __pyx_t_2; + __Pyx_RefNannySetupContext("c_to_fortran_index_array", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":309 + * MUMPS_INT i + * + * for i from 0 <= i < a_size: # <<<<<<<<<<<<<< + * a[i] += 1 + * + */ + __pyx_t_1 = __pyx_v_a_size; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":310 + * + * for i from 0 <= i < a_size: + * a[i] += 1 # <<<<<<<<<<<<<< + * + * # MUMPS CONTEXT + */ + __pyx_t_2 = __pyx_v_i; + (__pyx_v_a[__pyx_t_2]) = ((__pyx_v_a[__pyx_t_2]) + 1); + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + MUMPS_INT __pyx_v_n; + MUMPS_INT __pyx_v_nnz; + PyObject *__pyx_v_comm_fortran = 0; + PyObject *__pyx_v_sym = 0; + PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":324 + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128___cinit__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128___cinit__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":333 + * verbose: a boolean to turn on or off the verbosity of MUMPS + * """ + * self.nrow = n # <<<<<<<<<<<<<< + * self.ncol = n + * self.nnz = nnz + */ + __pyx_v_self->nrow = __pyx_v_n; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":334 + * """ + * self.nrow = n + * self.ncol = n # <<<<<<<<<<<<<< + * self.nnz = nnz + * + */ + __pyx_v_self->ncol = __pyx_v_n; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":335 + * self.nrow = n + * self.ncol = n + * self.nnz = nnz # <<<<<<<<<<<<<< + * + * assert self.ncol == self.nrow + */ + __pyx_v_self->nnz = __pyx_v_nnz; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":337 + * self.nnz = nnz + * + * assert self.ncol == self.nrow # <<<<<<<<<<<<<< + * + * self.initialize_mumps_struct(comm_fortran, sym) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_self->ncol == __pyx_v_self->nrow) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":339 + * assert self.ncol == self.nrow + * + * self.initialize_mumps_struct(comm_fortran, sym) # <<<<<<<<<<<<<< + * + * # `initialize_mumps_struct` **must** be called before assigning + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->initialize_mumps_struct(__pyx_v_self, __pyx_v_comm_fortran, __pyx_v_sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":343 + * # `initialize_mumps_struct` **must** be called before assigning + * # a value to n (size of the matrix) + * self.params.n = self.nrow # <<<<<<<<<<<<<< + * + * self.analyzed = False + */ + __pyx_v_self->params.n = ((MUMPS_INT)__pyx_v_self->nrow); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":345 + * self.params.n = self.nrow + * + * self.analyzed = False # <<<<<<<<<<<<<< + * self.factorized = False + * self.out_of_core = False + */ + __pyx_v_self->analyzed = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":346 + * + * self.analyzed = False + * self.factorized = False # <<<<<<<<<<<<<< + * self.out_of_core = False + * + */ + __pyx_v_self->factorized = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":347 + * self.analyzed = False + * self.factorized = False + * self.out_of_core = False # <<<<<<<<<<<<<< + * + * if not verbose: + */ + __pyx_v_self->out_of_core = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = ((!__pyx_t_2) != 0); + if (__pyx_t_3) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":350 + * + * if not verbose: + * self.set_silent() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_silent); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("initialize_mumps_struct", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":362 + * sym: a boolean indicating if A is a symmetric matrix or not + * """ + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.params.sym = sym + * self.params.par = 1 + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":363 + * """ + * self.params.job = -1 + * self.params.sym = sym # <<<<<<<<<<<<<< + * self.params.par = 1 + * + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_sym); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":364 + * self.params.job = -1 + * self.params.sym = sym + * self.params.par = 1 # <<<<<<<<<<<<<< + * + * self.params.comm_fortran = comm_fortran + */ + __pyx_v_self->params.par = 1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":366 + * self.params.par = 1 + * + * self.params.comm_fortran = comm_fortran # <<<<<<<<<<<<<< + * + * self.mumps_call() + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_comm_fortran); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":368 + * self.params.comm_fortran = comm_fortran + * + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # integer control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":371 + * + * # integer control parameters + * self.icntl = mumps_int_array() # <<<<<<<<<<<<<< + * self.icntl.get_array(self.params.icntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 371; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->icntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_v_self->icntl = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":372 + * # integer control parameters + * self.icntl = mumps_int_array() + * self.icntl.get_array(self.params.icntl) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_v_self->icntl->__pyx_vtab)->get_array(__pyx_v_self->icntl, __pyx_v_self->params.icntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":375 + * + * # integer information parameters + * self.info = mumps_int_array() # <<<<<<<<<<<<<< + * self.info.get_array(self.params.info) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->info); + __Pyx_DECREF(((PyObject *)__pyx_v_self->info)); + __pyx_v_self->info = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":376 + * # integer information parameters + * self.info = mumps_int_array() + * self.info.get_array(self.params.info) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_v_self->info->__pyx_vtab)->get_array(__pyx_v_self->info, __pyx_v_self->params.info, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":379 + * + * # integer information parameters + * self.infog = mumps_int_array() # <<<<<<<<<<<<<< + * self.infog.get_array(self.params.infog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->infog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->infog)); + __pyx_v_self->infog = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":380 + * # integer information parameters + * self.infog = mumps_int_array() + * self.infog.get_array(self.params.infog) # <<<<<<<<<<<<<< + * + * # real/complex control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)__pyx_v_self->infog->__pyx_vtab)->get_array(__pyx_v_self->infog, __pyx_v_self->params.infog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":383 + * + * # real/complex control parameters + * self.cntl = zmumps_real_array() # <<<<<<<<<<<<<< + * self.cntl.get_array(self.params.cntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->cntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_v_self->cntl = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":384 + * # real/complex control parameters + * self.cntl = zmumps_real_array() + * self.cntl.get_array(self.params.cntl) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_v_self->cntl->__pyx_vtab)->get_array(__pyx_v_self->cntl, __pyx_v_self->params.cntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 384; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":387 + * + * # real/complex information parameters + * self.rinfo = zmumps_real_array() # <<<<<<<<<<<<<< + * self.rinfo.get_array(self.params.rinfo) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfo); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_v_self->rinfo = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":388 + * # real/complex information parameters + * self.rinfo = zmumps_real_array() + * self.rinfo.get_array(self.params.rinfo) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_v_self->rinfo->__pyx_vtab)->get_array(__pyx_v_self->rinfo, __pyx_v_self->params.rinfo, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":391 + * + * # real/complex information parameters + * self.rinfog = zmumps_real_array() # <<<<<<<<<<<<<< + * self.rinfog.get_array(self.params.rinfog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_v_self->rinfog = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":392 + * # real/complex information parameters + * self.rinfog = zmumps_real_array() + * self.rinfog.get_array(self.params.rinfog) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)__pyx_v_self->rinfog->__pyx_vtab)->get_array(__pyx_v_self->rinfog, __pyx_v_self->params.rinfog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.initialize_mumps_struct", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_get_data_pointers(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, ZMUMPS_COMPLEX *__pyx_v_a_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_data_pointers", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":410 + * """ + * + * self.a_row = a_row # <<<<<<<<<<<<<< + * self.a_col = a_col + * self.a_val = a_val + */ + __pyx_v_self->a_row = ((MUMPS_INT *)__pyx_v_a_row); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":411 + * + * self.a_row = a_row + * self.a_col = a_col # <<<<<<<<<<<<<< + * self.a_val = a_val + * + */ + __pyx_v_self->a_col = ((MUMPS_INT *)__pyx_v_a_col); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":412 + * self.a_row = a_row + * self.a_col = a_col + * self.a_val = a_val # <<<<<<<<<<<<<< + * + * # transform c index arrays to fortran arrays + */ + __pyx_v_self->a_val = ((ZMUMPS_COMPLEX *)__pyx_v_a_val); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":415 + * + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) # <<<<<<<<<<<<<< + * c_to_fortran_index_array(self.a_col, self.nnz) + * + */ + __pyx_t_1 = __pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_c_to_fortran_index_array(__pyx_v_self->a_row, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":416 + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) + * c_to_fortran_index_array(self.a_col, self.nnz) # <<<<<<<<<<<<<< + * + * self.set_centralized_assembled_matrix() + */ + __pyx_t_1 = __pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_c_to_fortran_index_array(__pyx_v_self->a_col, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":418 + * c_to_fortran_index_array(self.a_col, self.nnz) + * + * self.set_centralized_assembled_matrix() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->set_centralized_assembled_matrix(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.get_data_pointers", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_centralized_assembled_matrix", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":427 + * """ + * + * self.params.nz = self.nnz # <<<<<<<<<<<<<< + * + * self.params.irn = self.a_row + */ + __pyx_v_self->params.nz = ((MUMPS_INT)__pyx_v_self->nnz); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":429 + * self.params.nz = self.nnz + * + * self.params.irn = self.a_row # <<<<<<<<<<<<<< + * self.params.jcn = self.a_col + * self.params.a = self.a_val + */ + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_self->a_row); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":430 + * + * self.params.irn = self.a_row + * self.params.jcn = self.a_col # <<<<<<<<<<<<<< + * self.params.a = self.a_val + * + */ + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_self->a_col); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":431 + * self.params.irn = self.a_row + * self.params.jcn = self.a_col + * self.params.a = self.a_val # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_self->params.a = ((ZMUMPS_COMPLEX *)__pyx_v_self->a_val); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + +/* Python wrapper */ +static void __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2__dealloc__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2__dealloc__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":436 + * def __dealloc__(self): + * # autodestruct mumps internal + * self.params.job = -2 # <<<<<<<<<<<<<< + * self.mumps_call() + * self.params.job = -1 + */ + __pyx_v_self->params.job = -2; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":437 + * # autodestruct mumps internal + * self.params.job = -2 + * self.mumps_call() # <<<<<<<<<<<<<< + * self.params.job = -1 + * self.mumps_call() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":438 + * self.params.job = -2 + * self.mumps_call() + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":439 + * self.mumps_call() + * self.params.job = -1 + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # Properties + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_WriteUnraisable("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":444 + * # COMMON Properties + * property analyzed: + * def __get__(self): return self.analyzed # <<<<<<<<<<<<<< + * property factorized: + * def __get__(self): return self.factorized + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8analyzed_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8analyzed_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8analyzed___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8analyzed___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->analyzed); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.analyzed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":446 + * def __get__(self): return self.analyzed + * property factorized: + * def __get__(self): return self.factorized # <<<<<<<<<<<<<< + * property sym: + * def __get__(self): return self.params.sym + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10factorized_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10factorized_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10factorized___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10factorized___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->factorized); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.factorized.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":448 + * def __get__(self): return self.factorized + * property sym: + * def __get__(self): return self.params.sym # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.sym = value + * property par: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.sym.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":449 + * property sym: + * def __get__(self): return self.params.sym + * def __set__(self, value): self.params.sym = value # <<<<<<<<<<<<<< + * property par: + * def __get__(self): return self.params.par + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.sym.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":451 + * def __set__(self, value): self.params.sym = value + * property par: + * def __get__(self): return self.params.par # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.par = value + * property job: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.par); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.par.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":452 + * property par: + * def __get__(self): return self.params.par + * def __set__(self, value): self.params.par = value # <<<<<<<<<<<<<< + * property job: + * def __get__(self): return self.params.job + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 452; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.par = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.par.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":454 + * def __set__(self, value): self.params.par = value + * property job: + * def __get__(self): return self.params.job # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.job = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.job); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.job.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":455 + * property job: + * def __get__(self): return self.params.job + * def __set__(self, value): self.params.job = value # <<<<<<<<<<<<<< + * + * property comm_fortran: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.job = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.job.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":458 + * + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.comm_fortran = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.comm_fortran); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 458; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.comm_fortran.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":459 + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran + * def __set__(self, value): self.params.comm_fortran = value # <<<<<<<<<<<<<< + * + * property icntl: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 459; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.comm_fortran.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5icntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5icntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5icntl___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5icntl___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":463 + * property icntl: + * def __get__(self): + * return self.icntl # <<<<<<<<<<<<<< + * + * property n: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_r = ((PyObject *)__pyx_v_self->icntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":466 + * + * property n: + * def __get__(self): return self.params.n # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.n = value + * property nz_alloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.n); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.n.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":467 + * property n: + * def __get__(self): return self.params.n + * def __set__(self, value): self.params.n = value # <<<<<<<<<<<<<< + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.n = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.n.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":469 + * def __set__(self, value): self.params.n = value + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_alloc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_alloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 469; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz_alloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":470 + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + * def __set__(self, value): self.params.nz_alloc = value # <<<<<<<<<<<<<< + * + * property nz: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 470; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_alloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz_alloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":473 + * + * property nz: + * def __get__(self): return self.params.nz # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz = value + * property irn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 473; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":474 + * property nz: + * def __get__(self): return self.params.nz + * def __set__(self, value): self.params.nz = value # <<<<<<<<<<<<<< + * property irn: + * def __get__(self): return self.params.irn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":476 + * def __set__(self, value): self.params.nz = value + * property irn: + * def __get__(self): return self.params.irn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn = value + * property jcn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":477 + * property irn: + * def __get__(self): return self.params.irn + * def __set__(self, long value): self.params.irn = value # <<<<<<<<<<<<<< + * property jcn: + * def __get__(self): return self.params.jcn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":479 + * def __set__(self, long value): self.params.irn = value + * property jcn: + * def __get__(self): return self.params.jcn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.jcn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":480 + * property jcn: + * def __get__(self): return self.params.jcn + * def __set__(self, long value): self.params.jcn = value # <<<<<<<<<<<<<< + * + * property nz_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.jcn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":483 + * + * property nz_loc: + * def __get__(self): return self.params.nz_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":484 + * property nz_loc: + * def __get__(self): return self.params.nz_loc + * def __set__(self, value): self.params.nz_loc = value # <<<<<<<<<<<<<< + * property irn_loc: + * def __get__(self): return self.params.irn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":486 + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + * def __get__(self): return self.params.irn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":487 + * property irn_loc: + * def __get__(self): return self.params.irn_loc + * def __set__(self, long value): self.params.irn_loc = value # <<<<<<<<<<<<<< + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":489 + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.jcn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":490 + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + * def __set__(self, long value): self.params.jcn_loc = value # <<<<<<<<<<<<<< + * + * property nelt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 490; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.jcn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":493 + * + * property nelt: + * def __get__(self): return self.params.nelt # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nelt = value + * property eltptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nelt); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 493; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nelt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":494 + * property nelt: + * def __get__(self): return self.params.nelt + * def __set__(self, value): self.params.nelt = value # <<<<<<<<<<<<<< + * property eltptr: + * def __get__(self): return self.params.eltptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 494; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nelt = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nelt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":496 + * def __set__(self, value): self.params.nelt = value + * property eltptr: + * def __get__(self): return self.params.eltptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 496; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.eltptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":497 + * property eltptr: + * def __get__(self): return self.params.eltptr + * def __set__(self, long value): self.params.eltptr = value # <<<<<<<<<<<<<< + * property eltvar: + * def __get__(self): return self.params.eltvar + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 497; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.eltptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":499 + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + * def __get__(self): return self.params.eltvar # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltvar = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltvar)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.eltvar.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":500 + * property eltvar: + * def __get__(self): return self.params.eltvar + * def __set__(self, long value): self.params.eltvar = value # <<<<<<<<<<<<<< + * + * property perm_in: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.eltvar.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltvar = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":503 + * + * property perm_in: + * def __get__(self): return self.params.perm_in # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.perm_in = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.perm_in)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 503; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.perm_in.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":504 + * property perm_in: + * def __get__(self): return self.params.perm_in + * def __set__(self, long value): self.params.perm_in = value # <<<<<<<<<<<<<< + * + * property sym_perm: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.perm_in.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.perm_in = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":507 + * + * property sym_perm: + * def __get__(self): return self.params.sym_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sym_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.sym_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":508 + * property sym_perm: + * def __get__(self): return self.params.sym_perm + * def __set__(self, long value): self.params.sym_perm = value # <<<<<<<<<<<<<< + * property uns_perm: + * def __get__(self): return self.params.uns_perm + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 508; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.sym_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sym_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":510 + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + * def __get__(self): return self.params.uns_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.uns_perm = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.uns_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.uns_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":511 + * property uns_perm: + * def __get__(self): return self.params.uns_perm + * def __set__(self, long value): self.params.uns_perm = value # <<<<<<<<<<<<<< + * + * property irhs_sparse: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.uns_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.uns_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":514 + * + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 514; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":515 + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse + * def __set__(self, long value): self.params.irhs_sparse = value # <<<<<<<<<<<<<< + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 515; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":517 + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_ptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 517; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irhs_ptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":518 + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + * def __set__(self, long value): self.params.irhs_ptr = value # <<<<<<<<<<<<<< + * property isol_loc: + * def __get__(self): return self.params.isol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.irhs_ptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":520 + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + * def __get__(self): return self.params.isol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.isol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.isol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 520; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.isol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":521 + * property isol_loc: + * def __get__(self): return self.params.isol_loc + * def __set__(self, long value): self.params.isol_loc = value # <<<<<<<<<<<<<< + * + * property nrhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 521; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.isol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.isol_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":524 + * + * property nrhs: + * def __get__(self): return self.params.nrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":525 + * property nrhs: + * def __get__(self): return self.params.nrhs + * def __set__(self, value): self.params.nrhs = value # <<<<<<<<<<<<<< + * property lrhs: + * def __get__(self): return self.params.lrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":527 + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + * def __get__(self): return self.params.lrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":528 + * property lrhs: + * def __get__(self): return self.params.lrhs + * def __set__(self, value): self.params.lrhs = value # <<<<<<<<<<<<<< + * property lredrhs: + * def __get__(self): return self.params.lredrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":530 + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + * def __get__(self): return self.params.lredrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lredrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 530; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lredrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":531 + * property lredrhs: + * def __get__(self): return self.params.lredrhs + * def __set__(self, value): self.params.lredrhs = value # <<<<<<<<<<<<<< + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 531; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lredrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lredrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":533 + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_rhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 533; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz_rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":534 + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + * def __set__(self, value): self.params.nz_rhs = value # <<<<<<<<<<<<<< + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 534; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_rhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nz_rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":536 + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lsol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lsol_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lsol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":537 + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + * def __set__(self, value): self.params.lsol_loc = value # <<<<<<<<<<<<<< + * + * property schur_mloc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lsol_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lsol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":540 + * + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_mloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur_mloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":541 + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc + * def __set__(self, value): self.params.schur_mloc = value # <<<<<<<<<<<<<< + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 541; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_mloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur_mloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":543 + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_nloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 543; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur_nloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":544 + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + * def __set__(self, value): self.params.schur_nloc = value # <<<<<<<<<<<<<< + * property schur_lld: + * def __get__(self): return self.params.schur_lld + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_nloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur_nloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":546 + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + * def __get__(self): return self.params.schur_lld # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_lld = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_lld); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 546; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur_lld.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":547 + * property schur_lld: + * def __get__(self): return self.params.schur_lld + * def __set__(self, value): self.params.schur_lld = value # <<<<<<<<<<<<<< + * + * property mblock: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_lld = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur_lld.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":550 + * + * property mblock: + * def __get__(self): return self.params.mblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.mblock = value + * property nblock: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.mblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 550; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.mblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":551 + * property mblock: + * def __get__(self): return self.params.mblock + * def __set__(self, value): self.params.mblock = value # <<<<<<<<<<<<<< + * property nblock: + * def __get__(self): return self.params.nblock + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 551; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.mblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.mblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":553 + * def __set__(self, value): self.params.mblock = value + * property nblock: + * def __get__(self): return self.params.nblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nblock = value + * property nprow: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":554 + * property nblock: + * def __get__(self): return self.params.nblock + * def __set__(self, value): self.params.nblock = value # <<<<<<<<<<<<<< + * property nprow: + * def __get__(self): return self.params.nprow + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 554; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":556 + * def __set__(self, value): self.params.nblock = value + * property nprow: + * def __get__(self): return self.params.nprow # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nprow = value + * property npcol: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nprow); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nprow.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":557 + * property nprow: + * def __get__(self): return self.params.nprow + * def __set__(self, value): self.params.nprow = value # <<<<<<<<<<<<<< + * property npcol: + * def __get__(self): return self.params.npcol + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nprow = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.nprow.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":559 + * def __set__(self, value): self.params.nprow = value + * property npcol: + * def __get__(self): return self.params.npcol # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.npcol = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.npcol); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.npcol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":560 + * property npcol: + * def __get__(self): return self.params.npcol + * def __set__(self, value): self.params.npcol = value # <<<<<<<<<<<<<< + * + * property info: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.npcol = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.npcol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4info_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4info_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4info___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4info___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":564 + * property info: + * def __get__(self): + * return self.info # <<<<<<<<<<<<<< + * + * property infog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->info)); + __pyx_r = ((PyObject *)__pyx_v_self->info); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5infog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5infog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5infog___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5infog___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":568 + * property infog: + * def __get__(self): + * return self.infog # <<<<<<<<<<<<<< + * + * property deficiency: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __pyx_r = ((PyObject *)__pyx_v_self->infog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":571 + * + * property deficiency: + * def __get__(self): return self.params.deficiency # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.deficiency); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.deficiency.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":572 + * property deficiency: + * def __get__(self): return self.params.deficiency + * def __set__(self, value): self.params.deficiency = value # <<<<<<<<<<<<<< + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.deficiency = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.deficiency.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":574 + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.pivnul_list)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 574; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.pivnul_list.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":575 + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + * def __set__(self, long value): self.params.pivnul_list = value # <<<<<<<<<<<<<< + * property mapping: + * def __get__(self): return self.params.mapping + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 575; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.pivnul_list.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.pivnul_list = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":577 + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + * def __get__(self): return self.params.mapping # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.mapping = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.mapping)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.mapping.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":578 + * property mapping: + * def __get__(self): return self.params.mapping + * def __set__(self, long value): self.params.mapping = value # <<<<<<<<<<<<<< + * + * property size_schur: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 578; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.mapping.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.mapping = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":581 + * + * property size_schur: + * def __get__(self): return self.params.size_schur # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.size_schur); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 581; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.size_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":582 + * property size_schur: + * def __get__(self): return self.params.size_schur + * def __set__(self, value): self.params.size_schur = value # <<<<<<<<<<<<<< + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 582; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.size_schur = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.size_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":584 + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.listvar_schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.listvar_schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 584; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.listvar_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":585 + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + * def __set__(self, long value): self.params.listvar_schur = value # <<<<<<<<<<<<<< + * + * property instance_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.listvar_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.listvar_schur = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":588 + * + * property instance_number: + * def __get__(self): return self.params.instance_number # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.instance_number = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.instance_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.instance_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":589 + * property instance_number: + * def __get__(self): return self.params.instance_number + * def __set__(self, value): self.params.instance_number = value # <<<<<<<<<<<<<< + * + * property version_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 589; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.instance_number = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.instance_number.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_14version_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_14version_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_14version_number___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_14version_number___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":593 + * property version_number: + * def __get__(self): + * return ( self.params.version_number).decode('ascii') # <<<<<<<<<<<<<< + * + * property ooc_tmpdir: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.version_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.version_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":597 + * property ooc_tmpdir: + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_tmpdir); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.ooc_tmpdir.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 598; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.ooc_tmpdir.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":599 + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) # <<<<<<<<<<<<<< + * property ooc_prefix: + * def __get__(self): + */ + strncpy(__pyx_v_self->params.ooc_tmpdir, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_tmpdir))); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":602 + * property ooc_prefix: + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_prefix); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.ooc_prefix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 603; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.ooc_prefix.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":604 + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) # <<<<<<<<<<<<<< + * + * property write_problem: + */ + strncpy(__pyx_v_self->params.ooc_prefix, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_prefix))); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":608 + * property write_problem: + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.write_problem); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.write_problem.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.write_problem.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":610 + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) # <<<<<<<<<<<<<< + * + * property lwk_user: + */ + strncpy(__pyx_v_self->params.write_problem, __pyx_v_value, (sizeof(__pyx_v_self->params.write_problem))); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":613 + * + * property lwk_user: + * def __get__(self): return self.params.lwk_user # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lwk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lwk_user); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lwk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":614 + * property lwk_user: + * def __get__(self): return self.params.lwk_user + * def __set__(self, value): self.params.lwk_user = value # <<<<<<<<<<<<<< + * + * # TYPED Properties + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lwk_user = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.lwk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4cntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4cntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4cntl___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4cntl___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":619 + * property cntl: + * def __get__(self): + * return self.cntl # <<<<<<<<<<<<<< + * + * property a: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_r = ((PyObject *)__pyx_v_self->cntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":622 + * + * property a: + * def __get__(self): return self.params.a # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.a.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":623 + * property a: + * def __get__(self): return self.params.a + * def __set__(self, long value): self.params.a = value # <<<<<<<<<<<<<< + * + * property a_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.a.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":626 + * + * property a_loc: + * def __get__(self): return self.params.a_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 626; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.a_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":627 + * property a_loc: + * def __get__(self): return self.params.a_loc + * def __set__(self, long value): self.params.a_loc = value # <<<<<<<<<<<<<< + * + * property a_elt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 627; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.a_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_loc = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":630 + * + * property a_elt: + * def __get__(self): return self.params.a_elt # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_elt = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_elt)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 630; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.a_elt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":631 + * property a_elt: + * def __get__(self): return self.params.a_elt + * def __set__(self, long value): self.params.a_elt = value # <<<<<<<<<<<<<< + * + * property colsca: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.a_elt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_elt = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":634 + * + * property colsca: + * def __get__(self): return self.params.colsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.colsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.colsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":635 + * property colsca: + * def __get__(self): return self.params.colsca + * def __set__(self, long value): self.params.colsca = value # <<<<<<<<<<<<<< + * property rowsca: + * def __get__(self): return self.params.rowsca + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.colsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.colsca = ((ZMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":637 + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + * def __get__(self): return self.params.rowsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rowsca = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rowsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.rowsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":638 + * property rowsca: + * def __get__(self): return self.params.rowsca + * def __set__(self, long value): self.params.rowsca = value # <<<<<<<<<<<<<< + * + * property rhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.rowsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rowsca = ((ZMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":641 + * + * property rhs: + * def __get__(self): return self.params.rhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 641; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":642 + * property rhs: + * def __get__(self): return self.params.rhs + * def __set__(self, long value): self.params.rhs = value # <<<<<<<<<<<<<< + * property redrhs: + * def __get__(self): return self.params.redrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":644 + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + * def __get__(self): return self.params.redrhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.redrhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.redrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":645 + * property redrhs: + * def __get__(self): return self.params.redrhs + * def __set__(self, long value): self.params.redrhs = value # <<<<<<<<<<<<<< + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 645; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.redrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.redrhs = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":647 + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.rhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":648 + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + * def __set__(self, long value): self.params.rhs_sparse = value # <<<<<<<<<<<<<< + * property sol_loc: + * def __get__(self): return self.params.sol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.rhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs_sparse = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":650 + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + * def __get__(self): return self.params.sol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.sol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":651 + * property sol_loc: + * def __get__(self): return self.params.sol_loc + * def __set__(self, long value): self.params.sol_loc = value # <<<<<<<<<<<<<< + * + * property rinfo: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.sol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sol_loc = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5rinfo_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5rinfo_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5rinfo___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5rinfo___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":655 + * property rinfo: + * def __get__(self): + * return self.rinfo # <<<<<<<<<<<<<< + * + * property rinfog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfo); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rinfog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rinfog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rinfog___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rinfog___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":659 + * property rinfog: + * def __get__(self): + * return self.rinfog # <<<<<<<<<<<<<< + * + * property schur: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":662 + * + * property schur: + * def __get__(self): return self.params.schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":663 + * property schur: + * def __get__(self): return self.params.schur + * def __set__(self, long value): self.params.schur = value # <<<<<<<<<<<<<< + * + * property wk_user: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.schur = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":666 + * + * property wk_user: + * def __get__(self): return self.params.wk_user # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.wk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user___get__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user___get__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.wk_user)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.wk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":667 + * property wk_user: + * def __get__(self): return self.params.wk_user + * def __set__(self, long value): self.params.wk_user = value # <<<<<<<<<<<<<< + * + * # MUMPS CALL + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 667; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.wk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_2__set__(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.wk_user = ((ZMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mumps_call(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mumps_call", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":674 + * Call to Xmumps_c(XMUMPS_STRUC_C). + * """ + * zmumps_c(&self.params) # <<<<<<<<<<<<<< + * + * + */ + zmumps_c((&__pyx_v_self->params)); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4set_silent[] = "\n Silence **all* MUMPS output.\n\n See MUMPS documentation.\n "; +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_silent (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4set_silent(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4set_silent(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_silent", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":683 + * See MUMPS documentation. + * """ + * self.icntl[1] = 0 # <<<<<<<<<<<<<< + * self.icntl[2] = 0 + * self.icntl[3] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 1, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":684 + * """ + * self.icntl[1] = 0 + * self.icntl[2] = 0 # <<<<<<<<<<<<<< + * self.icntl[3] = 0 + * self.icntl[4] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":685 + * self.icntl[1] = 0 + * self.icntl[2] = 0 + * self.icntl[3] = 0 # <<<<<<<<<<<<<< + * self.icntl[4] = 0 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 3, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":686 + * self.icntl[2] = 0 + * self.icntl[3] = 0 + * self.icntl[4] = 0 # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 4, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.set_silent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6analyze[] = "\n Performs analysis step of MUMPS.\n\n In the analyis step, MUMPS is able to figure out a reordering for the \n given matrix. It does so if `ordering` is set to 'auto'.\n If not MUMPS will use the provided ordering.\n MUMPS statistics for the analysis are available in `analysis_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n "; +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("analyze (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "analyze") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("analyze", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6analyze(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), __pyx_v_ordering); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6analyze(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_ordering) { + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("analyze", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_1 = (__pyx_v_self->analyzed != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":705 + * """ + * if self.analyzed: + * return # <<<<<<<<<<<<<< + * + * self.icntl[7] = orderings[ordering] + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":707 + * return + * + * self.icntl[7] = orderings[ordering] # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.params.job = 1 # analyse + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_orderings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_ordering); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 7, __pyx_t_3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":708 + * + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.params.job = 1 # analyse + * self.mumps_call() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_t1 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":709 + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() + * self.params.job = 1 # analyse # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_v_self->params.job = 1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":710 + * t1 = time.clock() + * self.params.job = 1 # analyse + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":711 + * self.params.job = 1 # analyse + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * if self.infog[1] < 0: + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_t2 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":714 + * + * if self.infog[1] < 0: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * + * self.analyzed = True + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":716 + * raise MUMPSError(self.infog) + * + * self.analyzed = True # <<<<<<<<<<<<<< + * + * # self.analysis_stats = AnalysisStatistics(self.params, + */ + __pyx_v_self->analyzed = 1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8factorize[] = "\n Perform the LU factorization of the matrix (or LDL' if the matrix\n is symmetric).\n\n This factorization can then later be used to solve a linear system\n with `solve`. Statistical data of the factorization is stored in\n `factor_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n pivot_tol: number in the range [0, 1]\n pivoting threshold. Pivoting is typically limited in sparse\n solvers, as too much pivoting destroys sparsity. 1.0 means full\n pivoting, whereas 0.0 means no pivoting. Default is 0.01.\n "; +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + PyObject *__pyx_v_pivot_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("factorize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,&__pyx_n_s_pivot_tol,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + values[1] = ((PyObject *)__pyx_float_0_01); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pivot_tol); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "factorize") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + __pyx_v_pivot_tol = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("factorize", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8factorize(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), __pyx_v_ordering, __pyx_v_pivot_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8factorize(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol) { + int __pyx_v_done; + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("factorize", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + __pyx_t_1 = ((!(__pyx_v_self->analyzed != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":744 + * # Analysis phase must be done before factorization + * if not self.analyzed : + * self.analyze(ordering=ordering) # <<<<<<<<<<<<<< + * + * self.icntl[22] = 1 if self.out_of_core else 1 + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_analyze); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_ordering, __pyx_v_ordering) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":746 + * self.analyze(ordering=ordering) + * + * self.icntl[22] = 1 if self.out_of_core else 1 # <<<<<<<<<<<<<< + * self.cntl[1] = pivot_tol + * self.params.job = 2 + */ + if ((__pyx_v_self->out_of_core != 0)) { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 22, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":747 + * + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol # <<<<<<<<<<<<<< + * self.params.job = 2 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 1, __pyx_v_pivot_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":748 + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol + * self.params.job = 2 # <<<<<<<<<<<<<< + * + * done = False + */ + __pyx_v_self->params.job = 2; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":750 + * self.params.job = 2 + * + * done = False # <<<<<<<<<<<<<< + * while not done: + * t1 = time.clock() + */ + __pyx_v_done = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":751 + * + * done = False + * while not done: # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.mumps_call() + */ + while (1) { + __pyx_t_1 = ((!(__pyx_v_done != 0)) != 0); + if (!__pyx_t_1) break; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":752 + * done = False + * while not done: + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_t1, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":753 + * while not done: + * t1 = time.clock() + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":754 + * t1 = time.clock() + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * # error -8, -9 (not enough allocated memory) is treated + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_t2, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + __pyx_t_4 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_8, -8L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_5) { + } else { + __pyx_t_1 = __pyx_t_5; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_9, -9L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_L8_bool_binop_done:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":761 + * if self.infog[1] in (-8, -9): + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 # <<<<<<<<<<<<<< + * else: + * raise MUMPSError(self.infog) + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->icntl), 14, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_int_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 14, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":763 + * self.icntl[14] = self.icntl[14]*2 + * else: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * else: + * done = True + */ + /*else*/ { + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":765 + * raise MUMPSError(self.infog) + * else: + * done = True # <<<<<<<<<<<<<< + * + * self.factorized = True + */ + /*else*/ { + __pyx_v_done = 1; + } + __pyx_L6:; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":767 + * done = True + * + * self.factorized = True # <<<<<<<<<<<<<< + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + */ + __pyx_v_self->factorized = 1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, ZMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_solve_dense(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, ZMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_dense", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":782 + * MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + * """ + * self.params.nrhs = nrhs # <<<<<<<<<<<<<< + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + */ + __pyx_v_self->params.nrhs = ((MUMPS_INT)__pyx_v_nrhs); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":783 + * """ + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length # <<<<<<<<<<<<<< + * self.params.rhs = rhs + * self.params.job = 3 # solve + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_rhs_length); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":784 + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length + * self.params.rhs = rhs # <<<<<<<<<<<<<< + * self.params.job = 3 # solve + * self.mumps_call() + */ + __pyx_v_self->params.rhs = ((ZMUMPS_COMPLEX *)__pyx_v_rhs); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":785 + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":786 + * self.params.rhs = rhs + * self.params.job = 3 # solve + * self.mumps_call() # <<<<<<<<<<<<<< + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, ZMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.solve_dense", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * ZMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * ZMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + +static PyObject *__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_solve_sparse(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, ZMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, ZMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_sparse", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":807 + * + * """ + * self.params.nz_rhs = rhs_nnz # <<<<<<<<<<<<<< + * self.params.nrhs = nrhs # nrhs -1 ? + * + */ + __pyx_v_self->params.nz_rhs = __pyx_v_rhs_nnz; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":808 + * """ + * self.params.nz_rhs = rhs_nnz + * self.params.nrhs = nrhs # nrhs -1 ? # <<<<<<<<<<<<<< + * + * self.params.rhs_sparse = rhs_val + */ + __pyx_v_self->params.nrhs = __pyx_v_nrhs; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":810 + * self.params.nrhs = nrhs # nrhs -1 ? + * + * self.params.rhs_sparse = rhs_val # <<<<<<<<<<<<<< + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr + */ + __pyx_v_self->params.rhs_sparse = ((ZMUMPS_COMPLEX *)__pyx_v_rhs_val); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":811 + * + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind # <<<<<<<<<<<<<< + * self.params.irhs_ptr = rhs_col_ptr + * + */ + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_rhs_row_ind); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":812 + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr # <<<<<<<<<<<<<< + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + */ + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_rhs_col_ptr); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":815 + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length # <<<<<<<<<<<<<< + * self.params.rhs = x + * + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_x_length); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":816 + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length + * self.params.rhs = x # <<<<<<<<<<<<<< + * + * self.params.job = 3 # solve + */ + __pyx_v_self->params.rhs = ((ZMUMPS_COMPLEX *)__pyx_v_x); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":818 + * self.params.rhs = x + * + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":819 + * + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 20, __pyx_int_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":820 + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() # <<<<<<<<<<<<<< + * + * def solve(self, **kwargs): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * ZMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * ZMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.solve_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10solve[] = "\n\n Args:\n rhs: dense NumPy array (matrix or vector).\n rhs_col_ptr, rhs_row_ind, rhs_val: sparse NumPy CSC arrays (matrix or vector).\n transpose_solve : ``True`` or ``False`` whether to solve A * x = rhs or A^T * x = rhs. Default is ``False``\n\n Returns:\n Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system.\n "; +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_kwargs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solve (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;} + if (__pyx_kwds && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 1))) return NULL; + __pyx_v_kwargs = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10solve(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), __pyx_v_kwargs); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5solve_genexpr(PyObject *__pyx_self) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *)__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5solve_2generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_solve_locals_genexpr); if (unlikely(!gen)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.solve.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __pyx_tuple__3; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= 3) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_arg); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_arg, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs)) { __Pyx_RaiseClosureNameError("kwargs"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } + if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_cur_scope->__pyx_v_arg, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (__pyx_t_5) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + } + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10solve(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_kwargs) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *__pyx_cur_scope; + PyObject *__pyx_v_transpose_solve = NULL; + MUMPS_INT __pyx_v_nrhs; + PyObject *__pyx_v_rhs = NULL; + PyObject *__pyx_v_rhs_shape = NULL; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_v_rhs_col_ptr = NULL; + PyObject *__pyx_v_rhs_row_ind = NULL; + PyObject *__pyx_v_rhs_val = NULL; + MUMPS_INT __pyx_v_x_length; + PyObject *__pyx_v_rhs_nnz = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + MUMPS_INT __pyx_t_8; + MUMPS_INT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *)__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_v_kwargs = __pyx_v_kwargs; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_kwargs); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_kwargs); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + __pyx_t_1 = ((!(__pyx_v_self->factorized != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":834 + * """ + * if not self.factorized: + * self.factorize() # <<<<<<<<<<<<<< + * + * transpose_solve = kwargs.get('transpose_solve', False) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_factorize); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":836 + * self.factorize() + * + * transpose_solve = kwargs.get('transpose_solve', False) # <<<<<<<<<<<<<< + * self.icntl[9] = 2 if transpose_solve else 1 + * + */ + __pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_transpose_solve, Py_False); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_transpose_solve = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":837 + * + * transpose_solve = kwargs.get('transpose_solve', False) + * self.icntl[9] = 2 if transpose_solve else 1 # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_transpose_solve); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__pyx_t_1) { + __Pyx_INCREF(__pyx_int_2); + __pyx_t_2 = __pyx_int_2; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_2 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 9, __pyx_t_2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_rhs, __pyx_cur_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":844 + * # rhs can be dense or sparse + * if 'rhs' in kwargs: + * rhs = kwargs['rhs'] # <<<<<<<<<<<<<< + * + * if not cnp.PyArray_Check(rhs): + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_5 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":850 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":855 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # create x + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":853 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":858 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (__pyx_t_7) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":862 + * # test number of columns in rhs + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * nrhs = rhs_shape[1] + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":864 + * nrhs = 1 + * else: + * nrhs = rhs_shape[1] # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = ((MUMPS_INT)__pyx_t_8); + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":866 + * nrhs = rhs_shape[1] + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((ZMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_9, __pyx_v_nrhs); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_t_4 = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5solve_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_Generator_Next(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":870 + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] # <<<<<<<<<<<<<< + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_col_ptr); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_col_ptr = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":871 + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] # <<<<<<<<<<<<<< + * rhs_val = kwargs['rhs_val'] + * + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_row_ind); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_row_ind = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":872 + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] # <<<<<<<<<<<<<< + * + * # fortran indices, done internally in C: no efficiency lost + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_val); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 872; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_val = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":875 + * + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 # <<<<<<<<<<<<<< + * rhs_row_ind += 1 + * + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_col_ptr, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_col_ptr, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":876 + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 + * rhs_row_ind += 1 # <<<<<<<<<<<<<< + * + * nrhs = rhs_col_ptr.size - 1 + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_row_ind, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_row_ind, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":878 + * rhs_row_ind += 1 + * + * nrhs = rhs_col_ptr.size - 1 # <<<<<<<<<<<<<< + * x_length = self.nrow + * rhs_nnz = rhs_val.size + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_col_ptr, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = __pyx_t_8; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":879 + * + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow # <<<<<<<<<<<<<< + * rhs_nnz = rhs_val.size + * + */ + __pyx_t_9 = __pyx_v_self->nrow; + __pyx_v_x_length = __pyx_t_9; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":880 + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow + * rhs_nnz = rhs_val.size # <<<<<<<<<<<<<< + * + * x = np.zeros([self.nrow, nrhs], dtype=np.complex128) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_val, __pyx_n_s_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 880; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_rhs_nnz = __pyx_t_4; + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":882 + * rhs_nnz = rhs_val.size + * + * x = np.zeros([self.nrow, nrhs], dtype=np.complex128) # <<<<<<<<<<<<<< + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_nrhs); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex128); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_x = __pyx_t_6; + __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.complex128) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + if (!(likely(((__pyx_v_rhs_col_ptr) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_col_ptr, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_rhs_row_ind) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_row_ind, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":885 + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), # <<<<<<<<<<<<<< + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + */ + if (!(likely(((__pyx_v_rhs_val) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_val, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 885; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":886 + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) # <<<<<<<<<<<<<< + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + */ + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_rhs_nnz); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.complex128) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->solve_sparse(__pyx_v_self, ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_col_ptr))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_row_ind))), ((ZMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_val))), __pyx_t_9, __pyx_v_nrhs, ((ZMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_v_x_length); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L4:; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":890 + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + * + * return x # <<<<<<<<<<<<<< + * + * def refine(self, rhs, nitref = 3, tol=None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.solve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_transpose_solve); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XDECREF(__pyx_v_rhs_col_ptr); + __Pyx_XDECREF(__pyx_v_rhs_row_ind); + __Pyx_XDECREF(__pyx_v_rhs_val); + __Pyx_XDECREF(__pyx_v_rhs_nnz); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX128.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12refine[] = "\n refine(rhs, nitref) performs iterative refinement if necessary\n until the scaled residual norm ||b-Ax||/(1+||b||) falls below the\n threshold 'tol' or until nitref steps are taken.\n Parameters:\n nitref : < 0 : Fixed number of steps of iterative refinement. No stopping criterion is used. \n 0 : No iterative refinement.\n > 0 : Maximum number of steps of iterative refinement. A stopping criterion is used,\n therefore a test for convergence is done at each step of the iterative refinement algorithm.\n Default: 3\n tol : is the stopping criterion for iterative refinement\n\n Make sure you have called `solve()` with the same right-hand\n side rhs before calling `refine()`.\n The residual vector self.residual will be updated to reflect\n the updated approximate solution.\n "; +static PyObject *__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_rhs = 0; + PyObject *__pyx_v_nitref = 0; + PyObject *__pyx_v_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("refine (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rhs,&__pyx_n_s_nitref,&__pyx_n_s_tol,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)__pyx_int_3); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nitref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tol); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "refine") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_rhs = values[0]; + __pyx_v_nitref = values[1]; + __pyx_v_tol = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("refine", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12refine(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), __pyx_v_rhs, __pyx_v_nitref, __pyx_v_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12refine(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol) { + PyObject *__pyx_v_rhs_shape = NULL; + long __pyx_v_nrhs; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + MUMPS_INT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("refine", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_1 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":917 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":922 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs. + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":920 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":927 + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L5; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":929 + * nrhs = 1 + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ # <<<<<<<<<<<<<< + * "refinement.") + * + */ + /*else*/ { + __pyx_t_2 = PyNumber_Add(__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_kp_s_refinement); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L5:; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":933 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * self.icntl[10] = nitref + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":935 + * x = np.asfortranarray(rhs.copy()) + * + * self.icntl[10] = nitref # <<<<<<<<<<<<<< + * if tol is None: + * self.cntl[2] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_v_nitref, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + __pyx_t_1 = (__pyx_v_tol == Py_None); + __pyx_t_7 = (__pyx_t_1 != 0); + if (__pyx_t_7) { + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":937 + * self.icntl[10] = nitref + * if tol is None: + * self.cntl[2] = 0 # <<<<<<<<<<<<<< + * else: + * self.cntl[2] = tol + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":939 + * self.cntl[2] = 0 + * else: + * self.cntl[2] = tol # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_v_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L6:; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":941 + * self.cntl[2] = tol + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * # reset to default values + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_2); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((ZMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_8, __pyx_v_nrhs); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":944 + * + * # reset to default values + * self.icntl[10] = 0 # <<<<<<<<<<<<<< + * self.cntl[2] = -1 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":945 + * # reset to default values + * self.icntl[10] = 0 + * self.cntl[2] = -1 # <<<<<<<<<<<<<< + * + * return x + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_neg_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":947 + * self.cntl[2] = -1 + * + * return x # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; + +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; + if (unlikely(__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_mumps_int_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_mumps_int_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX128.mumps_int_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_mumps_int_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_mumps_int_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Integer version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; + +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; + if (unlikely(__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_zmumps_real_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_zmumps_real_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX128.zmumps_real_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_zmumps_real_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_zmumps_real_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Real version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + p->icntl = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->info = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->infog = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->cntl = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfo = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfog = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + p->solve_stats = Py_None; Py_INCREF(Py_None); + if (unlikely(__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128(PyObject *o) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->icntl); + Py_CLEAR(p->info); + Py_CLEAR(p->infog); + Py_CLEAR(p->cntl); + Py_CLEAR(p->rinfo); + Py_CLEAR(p->rinfog); + Py_CLEAR(p->analysis_stats); + Py_CLEAR(p->factorize_stats); + Py_CLEAR(p->solve_stats); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)o; + if (p->icntl) { + e = (*v)(((PyObject*)p->icntl), a); if (e) return e; + } + if (p->info) { + e = (*v)(((PyObject*)p->info), a); if (e) return e; + } + if (p->infog) { + e = (*v)(((PyObject*)p->infog), a); if (e) return e; + } + if (p->cntl) { + e = (*v)(((PyObject*)p->cntl), a); if (e) return e; + } + if (p->rinfo) { + e = (*v)(((PyObject*)p->rinfo), a); if (e) return e; + } + if (p->rinfog) { + e = (*v)(((PyObject*)p->rinfog), a); if (e) return e; + } + if (p->analysis_stats) { + e = (*v)(p->analysis_stats, a); if (e) return e; + } + if (p->factorize_stats) { + e = (*v)(p->factorize_stats, a); if (e) return e; + } + if (p->solve_stats) { + e = (*v)(p->solve_stats, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)o; + tmp = ((PyObject*)p->icntl); + p->icntl = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->info); + p->info = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->infog); + p->infog = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->cntl); + p->cntl = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfo); + p->rinfo = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfog); + p->rinfog = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->analysis_stats); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->factorize_stats); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->solve_stats); + p->solve_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_analyzed(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8analyzed_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_factorized(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10factorized_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3sym_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_par(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_par(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3par_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_job(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_job(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3job_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_comm_fortran(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_comm_fortran(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12comm_fortran_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_icntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5icntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_n(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_n(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1n_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_alloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_alloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8nz_alloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_2nz_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3irn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3jcn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7irn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7jcn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nelt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nelt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nelt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltvar(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltvar(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6eltvar_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_perm_in(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_perm_in(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7perm_in_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8sym_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_uns_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_uns_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8uns_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11irhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_ptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_ptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8irhs_ptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_isol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_isol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8isol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4nrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4lrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lredrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lredrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7lredrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nz_rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lsol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lsol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lsol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_mloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_mloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_mloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_nloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_nloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10schur_nloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_lld(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_lld(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9schur_lld_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6mblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6nblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nprow(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nprow(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5nprow_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_npcol(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_npcol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5npcol_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_info(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4info_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_infog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5infog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_deficiency(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_deficiency(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10deficiency_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_pivnul_list(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_pivnul_list(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11pivnul_list_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mapping(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mapping(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7mapping_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_size_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_size_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10size_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_listvar_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_listvar_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13listvar_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_instance_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_instance_number(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_15instance_number_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_version_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_14version_number_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_tmpdir(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_tmpdir(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_tmpdir_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_prefix(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_prefix(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10ooc_prefix_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_write_problem(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_write_problem(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13write_problem_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lwk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lwk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8lwk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_cntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4cntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_1a_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_elt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_elt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5a_elt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_colsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_colsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6colsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rowsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rowsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rowsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_3rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_redrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_redrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6redrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10rhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7sol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rinfo(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5rinfo_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rinfog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6rinfog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_wk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_wk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7wk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128[] = { + {"set_silent", (PyCFunction)__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_5set_silent, METH_NOARGS, __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_4set_silent}, + {"analyze", (PyCFunction)__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_7analyze, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_6analyze}, + {"factorize", (PyCFunction)__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_9factorize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_8factorize}, + {"solve", (PyCFunction)__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_11solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_10solve}, + {"refine", (PyCFunction)__pyx_pw_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_13refine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_12refine}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128[] = { + {(char *)"analyzed", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_analyzed, 0, 0, 0}, + {(char *)"factorized", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_factorized, 0, 0, 0}, + {(char *)"sym", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym, 0, 0}, + {(char *)"par", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_par, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_par, 0, 0}, + {(char *)"job", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_job, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_job, 0, 0}, + {(char *)"comm_fortran", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_comm_fortran, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_comm_fortran, 0, 0}, + {(char *)"icntl", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_icntl, 0, 0, 0}, + {(char *)"n", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_n, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_n, 0, 0}, + {(char *)"nz_alloc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_alloc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_alloc, 0, 0}, + {(char *)"nz", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz, 0, 0}, + {(char *)"irn", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn, 0, 0}, + {(char *)"jcn", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn, 0, 0}, + {(char *)"nz_loc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_loc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_loc, 0, 0}, + {(char *)"irn_loc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn_loc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irn_loc, 0, 0}, + {(char *)"jcn_loc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn_loc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_jcn_loc, 0, 0}, + {(char *)"nelt", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nelt, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nelt, 0, 0}, + {(char *)"eltptr", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltptr, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltptr, 0, 0}, + {(char *)"eltvar", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltvar, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_eltvar, 0, 0}, + {(char *)"perm_in", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_perm_in, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_perm_in, 0, 0}, + {(char *)"sym_perm", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym_perm, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sym_perm, 0, 0}, + {(char *)"uns_perm", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_uns_perm, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_uns_perm, 0, 0}, + {(char *)"irhs_sparse", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_sparse, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_sparse, 0, 0}, + {(char *)"irhs_ptr", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_ptr, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_irhs_ptr, 0, 0}, + {(char *)"isol_loc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_isol_loc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_isol_loc, 0, 0}, + {(char *)"nrhs", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nrhs, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nrhs, 0, 0}, + {(char *)"lrhs", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lrhs, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lrhs, 0, 0}, + {(char *)"lredrhs", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lredrhs, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lredrhs, 0, 0}, + {(char *)"nz_rhs", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_rhs, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nz_rhs, 0, 0}, + {(char *)"lsol_loc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lsol_loc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lsol_loc, 0, 0}, + {(char *)"schur_mloc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_mloc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_mloc, 0, 0}, + {(char *)"schur_nloc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_nloc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_nloc, 0, 0}, + {(char *)"schur_lld", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_lld, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur_lld, 0, 0}, + {(char *)"mblock", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mblock, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mblock, 0, 0}, + {(char *)"nblock", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nblock, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nblock, 0, 0}, + {(char *)"nprow", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nprow, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_nprow, 0, 0}, + {(char *)"npcol", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_npcol, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_npcol, 0, 0}, + {(char *)"info", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_info, 0, 0, 0}, + {(char *)"infog", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_infog, 0, 0, 0}, + {(char *)"deficiency", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_deficiency, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_deficiency, 0, 0}, + {(char *)"pivnul_list", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_pivnul_list, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_pivnul_list, 0, 0}, + {(char *)"mapping", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mapping, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mapping, 0, 0}, + {(char *)"size_schur", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_size_schur, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_size_schur, 0, 0}, + {(char *)"listvar_schur", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_listvar_schur, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_listvar_schur, 0, 0}, + {(char *)"instance_number", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_instance_number, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_instance_number, 0, 0}, + {(char *)"version_number", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_version_number, 0, 0, 0}, + {(char *)"ooc_tmpdir", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_tmpdir, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_tmpdir, 0, 0}, + {(char *)"ooc_prefix", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_prefix, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_ooc_prefix, 0, 0}, + {(char *)"write_problem", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_write_problem, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_write_problem, 0, 0}, + {(char *)"lwk_user", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lwk_user, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_lwk_user, 0, 0}, + {(char *)"cntl", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_cntl, 0, 0, 0}, + {(char *)"a", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a, 0, 0}, + {(char *)"a_loc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_loc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_loc, 0, 0}, + {(char *)"a_elt", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_elt, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_a_elt, 0, 0}, + {(char *)"colsca", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_colsca, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_colsca, 0, 0}, + {(char *)"rowsca", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rowsca, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rowsca, 0, 0}, + {(char *)"rhs", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs, 0, 0}, + {(char *)"redrhs", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_redrhs, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_redrhs, 0, 0}, + {(char *)"rhs_sparse", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs_sparse, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rhs_sparse, 0, 0}, + {(char *)"sol_loc", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sol_loc, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_sol_loc, 0, 0}, + {(char *)"rinfo", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rinfo, 0, 0, 0}, + {(char *)"rinfog", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_rinfog, 0, 0, 0}, + {(char *)"schur", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_schur, 0, 0}, + {(char *)"wk_user", __pyx_getprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_wk_user, __pyx_setprop_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_wk_user, 0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX128.BaseMUMPSSolver_INT32_COMPLEX128", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n Base MUMPS Context.\n\n This version **only** deals with array pointers.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *__pyx_freelist_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve[8]; +static int __pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve[--__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve(PyObject *o) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_kwargs); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve)))) { + __pyx_freelist_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve[__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve++] = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *)o; + if (p->__pyx_v_kwargs) { + e = (*v)(p->__pyx_v_kwargs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *)o; + tmp = ((PyObject*)p->__pyx_v_kwargs); + p->__pyx_v_kwargs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX128.__pyx_scope_struct__solve", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *__pyx_freelist_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr[8]; +static int __pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr[--__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_arg); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr)))) { + __pyx_freelist_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr[__pyx_freecount_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject*)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_arg) { + e = (*v)(p->__pyx_v_arg, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr *)o; + tmp = ((PyObject*)p->__pyx_outer_scope); + p->__pyx_outer_scope = ((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_arg); + p->__pyx_v_arg = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX128.__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "mumps_INT32_COMPLEX128", + __pyx_k_This_is_the_base_class_for_the, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_AnalysisStatistics, __pyx_k_AnalysisStatistics, sizeof(__pyx_k_AnalysisStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_FactorizationStatistics, __pyx_k_FactorizationStatistics, sizeof(__pyx_k_FactorizationStatistics), 0, 0, 1, 1}, + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError, __pyx_k_MUMPSError, sizeof(__pyx_k_MUMPSError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError___init, __pyx_k_MUMPSError___init, sizeof(__pyx_k_MUMPSError___init), 0, 0, 1, 1}, + {&__pyx_kp_s_MUMPS_error, __pyx_k_MUMPS_error, sizeof(__pyx_k_MUMPS_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_failed_with_error, __pyx_k_MUMPS_failed_with_error, sizeof(__pyx_k_MUMPS_failed_with_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st, __pyx_k_MUMPS_index_must_be_1_Fortran_st, sizeof(__pyx_k_MUMPS_index_must_be_1_Fortran_st), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_d, __pyx_k_MUMPS_index_must_be_d, sizeof(__pyx_k_MUMPS_index_must_be_d), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_numerically_singular, __pyx_k_Matrix_is_numerically_singular, sizeof(__pyx_k_Matrix_is_numerically_singular), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_singular_in_structure, __pyx_k_Matrix_is_singular_in_structure, sizeof(__pyx_k_Matrix_is_singular_in_structure), 0, 0, 1, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_kp_s_Not_enough_memory, __pyx_k_Not_enough_memory, sizeof(__pyx_k_Not_enough_memory), 0, 0, 1, 0}, + {&__pyx_kp_s_Not_enough_memory_during_analysi, __pyx_k_Not_enough_memory_during_analysi, sizeof(__pyx_k_Not_enough_memory_during_analysi), 0, 0, 1, 0}, + {&__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_k_Only_one_dense_rhs_is_allowed_fo, sizeof(__pyx_k_Only_one_dense_rhs_is_allowed_fo), 0, 0, 1, 0}, + {&__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_k_Right_hand_side_has_wrong_sizeAt, sizeof(__pyx_k_Right_hand_side_has_wrong_sizeAt), 0, 0, 1, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_SolveStatistics, __pyx_k_SolveStatistics, sizeof(__pyx_k_SolveStatistics), 0, 0, 1, 1}, + {&__pyx_kp_s_The_authors_of_MUMPS_would_like, __pyx_k_The_authors_of_MUMPS_would_like, sizeof(__pyx_k_The_authors_of_MUMPS_would_like), 0, 0, 1, 0}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_k_Users_syarra_work_VirtualEnvs_n, sizeof(__pyx_k_Users_syarra_work_VirtualEnvs_n), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_amd, __pyx_k_amd, sizeof(__pyx_k_amd), 0, 0, 1, 1}, + {&__pyx_n_s_amf, __pyx_k_amf, sizeof(__pyx_k_amf), 0, 0, 1, 1}, + {&__pyx_n_s_analyze, __pyx_k_analyze, sizeof(__pyx_k_analyze), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_n_s_asfortranarray, __pyx_k_asfortranarray, sizeof(__pyx_k_asfortranarray), 0, 0, 1, 1}, + {&__pyx_n_s_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 0, 1, 1}, + {&__pyx_n_s_clock, __pyx_k_clock, sizeof(__pyx_k_clock), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_complex128, __pyx_k_complex128, sizeof(__pyx_k_complex128), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_error_messages, __pyx_k_error_messages, sizeof(__pyx_k_error_messages), 0, 0, 1, 1}, + {&__pyx_n_s_factorize, __pyx_k_factorize, sizeof(__pyx_k_factorize), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_infog, __pyx_k_infog, sizeof(__pyx_k_infog), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_metis, __pyx_k_metis, sizeof(__pyx_k_metis), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_mumps_statistics, __pyx_k_mumps_mumps_statistics, sizeof(__pyx_k_mumps_mumps_statistics), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_src_mumps_INT32_COMPLEX128, __pyx_k_mumps_src_mumps_INT32_COMPLEX128, sizeof(__pyx_k_mumps_src_mumps_INT32_COMPLEX128), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_nitref, __pyx_k_nitref, sizeof(__pyx_k_nitref), 0, 0, 1, 1}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_ordering, __pyx_k_ordering, sizeof(__pyx_k_ordering), 0, 0, 1, 1}, + {&__pyx_n_s_ordering_name, __pyx_k_ordering_name, sizeof(__pyx_k_ordering_name), 0, 0, 1, 1}, + {&__pyx_n_s_orderings, __pyx_k_orderings, sizeof(__pyx_k_orderings), 0, 0, 1, 1}, + {&__pyx_n_s_pivot_tol, __pyx_k_pivot_tol, sizeof(__pyx_k_pivot_tol), 0, 0, 1, 1}, + {&__pyx_n_s_pord, __pyx_k_pord, sizeof(__pyx_k_pord), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_qamd, __pyx_k_qamd, sizeof(__pyx_k_qamd), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_kp_s_refinement, __pyx_k_refinement, sizeof(__pyx_k_refinement), 0, 0, 1, 0}, + {&__pyx_n_s_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_col_ptr, __pyx_k_rhs_col_ptr, sizeof(__pyx_k_rhs_col_ptr), 0, 0, 1, 1}, + {&__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP, __pyx_k_rhs_dense_arrays_must_be_an_NumP, sizeof(__pyx_k_rhs_dense_arrays_must_be_an_NumP), 0, 0, 1, 0}, + {&__pyx_kp_s_rhs_not_given_in_the_right_forma, __pyx_k_rhs_not_given_in_the_right_forma, sizeof(__pyx_k_rhs_not_given_in_the_right_forma), 0, 0, 1, 0}, + {&__pyx_n_s_rhs_row_ind, __pyx_k_rhs_row_ind, sizeof(__pyx_k_rhs_row_ind), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_val, __pyx_k_rhs_val, sizeof(__pyx_k_rhs_val), 0, 0, 1, 1}, + {&__pyx_n_s_scotch, __pyx_k_scotch, sizeof(__pyx_k_scotch), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, + {&__pyx_n_s_set_silent, __pyx_k_set_silent, sizeof(__pyx_k_set_silent), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, + {&__pyx_n_s_solve_locals_genexpr, __pyx_k_solve_locals_genexpr, sizeof(__pyx_k_solve_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, + {&__pyx_n_s_tol, __pyx_k_tol, sizeof(__pyx_k_tol), 0, 0, 1, 1}, + {&__pyx_n_s_transpose_solve, __pyx_k_transpose_solve, sizeof(__pyx_k_transpose_solve), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_kp_s_user_defined, __pyx_k_user_defined, sizeof(__pyx_k_user_defined), 0, 0, 1, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_tuple__3 = PyTuple_Pack(3, __pyx_n_s_rhs_col_ptr, __pyx_n_s_rhs_row_ind, __pyx_n_s_rhs_val); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_rhs_not_given_in_the_right_forma); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_tuple__13 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_infog, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_n_s_init, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_float_0_01 = PyFloat_FromDouble(0.01); if (unlikely(!__pyx_float_0_01)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_5 = PyInt_FromLong(-5); if (unlikely(!__pyx_int_neg_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_6 = PyInt_FromLong(-6); if (unlikely(!__pyx_int_neg_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_7 = PyInt_FromLong(-7); if (unlikely(!__pyx_int_neg_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_8 = PyInt_FromLong(-8); if (unlikely(!__pyx_int_neg_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_9 = PyInt_FromLong(-9); if (unlikely(!__pyx_int_neg_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_10 = PyInt_FromLong(-10); if (unlikely(!__pyx_int_neg_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_11 = PyInt_FromLong(-11); if (unlikely(!__pyx_int_neg_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_12 = PyInt_FromLong(-12); if (unlikely(!__pyx_int_neg_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_13 = PyInt_FromLong(-13); if (unlikely(!__pyx_int_neg_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initmumps_INT32_COMPLEX128(void); /*proto*/ +PyMODINIT_FUNC initmumps_INT32_COMPLEX128(void) +#else +PyMODINIT_FUNC PyInit_mumps_INT32_COMPLEX128(void); /*proto*/ +PyMODINIT_FUNC PyInit_mumps_INT32_COMPLEX128(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_mumps_INT32_COMPLEX128(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("mumps_INT32_COMPLEX128", __pyx_methods, __pyx_k_This_is_the_base_class_for_the, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__mumps_INT32_COMPLEX128) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.mumps_INT32_COMPLEX128")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.mumps_INT32_COMPLEX128", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("c_to_fortran_index_array", (void (*)(void))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Type init code ---*/ + __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array = &__pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array.tp_dict, __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "mumps_int_array", (PyObject *)&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array = &__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; + __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array = &__pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *, ZMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array.tp_dict, __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "zmumps_real_array", (PyObject *)&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array = &__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; + __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 = &__pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.get_data_pointers = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, MUMPS_INT *, MUMPS_INT *, ZMUMPS_COMPLEX *))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_get_data_pointers; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.initialize_mumps_struct = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, PyObject *, PyObject *))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_initialize_mumps_struct; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.mumps_call = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_mumps_call; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.set_centralized_assembled_matrix = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_set_centralized_assembled_matrix; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.solve_dense = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, ZMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_solve_dense; + __pyx_vtable_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.solve_sparse = (PyObject *(*)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, MUMPS_INT *, MUMPS_INT *, ZMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, ZMUMPS_COMPLEX *, MUMPS_INT))__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_32BaseMUMPSSolver_INT32_COMPLEX128_solve_sparse; + if (PyType_Ready(&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128.tp_dict, __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "BaseMUMPSSolver_INT32_COMPLEX128", (PyObject *)&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 = &__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + if (PyType_Ready(&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve.tp_print = 0; + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve = &__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct__solve; + if (PyType_Ready(&__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr.tp_print = 0; + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr = &__pyx_type_5mumps_3src_22mumps_INT32_COMPLEX128___pyx_scope_struct_1_genexpr; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":88 + * """ + * + * from mumps.mumps_statistics import AnalysisStatistics, FactorizationStatistics, SolveStatistics # <<<<<<<<<<<<<< + * + * from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free + */ + __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_AnalysisStatistics); + __Pyx_GIVEREF(__pyx_n_s_AnalysisStatistics); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_AnalysisStatistics); + __Pyx_INCREF(__pyx_n_s_FactorizationStatistics); + __Pyx_GIVEREF(__pyx_n_s_FactorizationStatistics); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_FactorizationStatistics); + __Pyx_INCREF(__pyx_n_s_SolveStatistics); + __Pyx_GIVEREF(__pyx_n_s_SolveStatistics); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_SolveStatistics); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_mumps_mumps_statistics, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AnalysisStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AnalysisStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FactorizationStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FactorizationStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SolveStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SolveStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":96 + * from libc.string cimport strncpy + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":99 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * import time + */ + import_array(); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":101 + * cnp.import_array() + * + * import time # <<<<<<<<<<<<<< + * + * cdef extern from "mumps_c_types.h": + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":214 + * + * # MUMPS possible ordering methods + * orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, # <<<<<<<<<<<<<< + * 'qamd' : 6, 'auto' : 7 } + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amd, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amf, __pyx_int_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scotch, __pyx_int_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_pord, __pyx_int_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_metis, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_qamd, __pyx_int_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_auto, __pyx_int_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_orderings, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":217 + * 'qamd' : 6, 'auto' : 7 } + * + * ordering_name = [ 'amd', 'user-defined', 'amf', # <<<<<<<<<<<<<< + * 'scotch', 'pord', 'metis', 'qamd'] + * + */ + __pyx_t_2 = PyList_New(7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_amd); + __Pyx_GIVEREF(__pyx_n_s_amd); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_amd); + __Pyx_INCREF(__pyx_kp_s_user_defined); + __Pyx_GIVEREF(__pyx_kp_s_user_defined); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_kp_s_user_defined); + __Pyx_INCREF(__pyx_n_s_amf); + __Pyx_GIVEREF(__pyx_n_s_amf); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_amf); + __Pyx_INCREF(__pyx_n_s_scotch); + __Pyx_GIVEREF(__pyx_n_s_scotch); + PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_scotch); + __Pyx_INCREF(__pyx_n_s_pord); + __Pyx_GIVEREF(__pyx_n_s_pord); + PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_pord); + __Pyx_INCREF(__pyx_n_s_metis); + __Pyx_GIVEREF(__pyx_n_s_metis); + PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_metis); + __Pyx_INCREF(__pyx_n_s_qamd); + __Pyx_GIVEREF(__pyx_n_s_qamd); + PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_qamd); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ordering_name, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":223 + * # TODO: decouple + * error_messages = { + * -5 : "Not enough memory during analysis phase", # <<<<<<<<<<<<<< + * -6 : "Matrix is singular in structure", + * -7 : "Not enough memory during analysis phase", + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_5, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_6, __pyx_kp_s_Matrix_is_singular_in_structure) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_7, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_10, __pyx_kp_s_Matrix_is_numerically_singular) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_11, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_12, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_13, __pyx_kp_s_Not_enough_memory) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_error_messages, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_builtin_RuntimeError); + __Pyx_GIVEREF(__pyx_builtin_RuntimeError); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_RuntimeError); + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_MUMPSError, __pyx_n_s_MUMPSError, (PyObject *) NULL, __pyx_n_s_mumps_src_mumps_INT32_COMPLEX128, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5mumps_3src_22mumps_INT32_COMPLEX128_10MUMPSError_1__init__, 0, __pyx_n_s_MUMPSError___init, NULL, __pyx_n_s_mumps_src_mumps_INT32_COMPLEX128, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_init, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MUMPSError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MUMPSError, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX128.pyx":1 + * """ # <<<<<<<<<<<<<< + * This is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home) + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.mumps_INT32_COMPLEX128", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.mumps_INT32_COMPLEX128"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return NULL; + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#endif + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return -1; + } + } + return m->sq_ass_item(o, i, v); + } + } +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) { +#else + if (is_list || PySequence_Check(o)) { +#endif + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15 + default: return PyLong_Type.tp_richcompare(op1, op2, Py_EQ); + #else + default: Py_RETURN_FALSE; + #endif + } + } + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + return PyObject_RichCompare(op1, op2, Py_EQ); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); +#else + if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } else { + if (default_value == Py_None) + default_value = NULL; + value = PyObject_CallMethodObjArgs( + d, __pyx_n_s_get, key, default_value, NULL); + } +#endif + return value; +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_COMPILING_IN_CPYTHON + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyMem_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +#if CYTHON_COMPILING_IN_PYPY +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + PyObject *self = f->m_self; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0 = PySequence_ITEM(arg, 0); + if (unlikely(!arg0)) return NULL; + result = (*meth)(self, arg0); + Py_DECREF(arg0); + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +#else +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return PyCFunction_Call(func, arg, kw); +} +#endif +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_Call, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { +#if !CYTHON_COMPILING_IN_PYPY + __pyx_CyFunctionType_type.tp_call = PyCFunction_Call; +#endif + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (__pyx_CyFunctionType == NULL) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyMem_Malloc(size); + if (!m->defaults) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(MUMPS_INT) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(MUMPS_INT), + little, !is_unsigned); + } +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; +#else + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); +#endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto bad; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + args = PyTuple_New(2); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +bad: + Py_XDECREF(method); + return result; +} + +#include +#include +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { +#if PY_VERSION_HEX >= 0x030300A0 + if (ev && Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } +#endif + if (!ev || !PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + ev = Py_None; + } else if (PyTuple_Check(ev)) { + if (PyTuple_GET_SIZE(ev) >= 1) { + PyObject *value; +#if CYTHON_COMPILING_IN_CPYTHON + value = PySequence_ITEM(ev, 0); +#else + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#endif + Py_DECREF(ev); + ev = value; + } else { + Py_INCREF(Py_None); + Py_DECREF(ev); + ev = Py_None; + } + } + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = ev; + return 0; + } + } else if (!PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if PY_VERSION_HEX >= 0x030300A0 + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); +#else + { + PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); + Py_DECREF(ev); + if (likely(args)) { + value = PySequence_GetItem(args, 0); + Py_DECREF(args); + } + if (unlikely(!value)) { + __Pyx_ErrRestore(NULL, NULL, NULL); + Py_INCREF(Py_None); + value = Py_None; + } + } +#endif + *pvalue = value; + return 0; +} +#endif +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__pyx_CoroutineObject *self) { + PyObject *exc_type = self->exc_type; + PyObject *exc_value = self->exc_value; + PyObject *exc_traceback = self->exc_traceback; + self->exc_type = NULL; + self->exc_value = NULL; + self->exc_traceback = NULL; + Py_XDECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_traceback); +} +static CYTHON_INLINE +int __Pyx_Coroutine_CheckRunning(__pyx_CoroutineObject *gen) { + if (unlikely(gen->is_running)) { + PyErr_SetString(PyExc_ValueError, + "generator already executing"); + return 1; + } + return 0; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) { + PyObject *retval; + assert(!self->is_running); + if (unlikely(self->resume_label == 0)) { + if (unlikely(value && value != Py_None)) { + PyErr_SetString(PyExc_TypeError, + "can't send non-None value to a " + "just-started generator"); + return NULL; + } + } + if (unlikely(self->resume_label == -1)) { + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } + if (value) { +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyThreadState *tstate = PyThreadState_GET(); + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_XINCREF(tstate->frame); + assert(f->f_back == NULL); + f->f_back = tstate->frame; + } +#endif + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + self->is_running = 1; + retval = self->body((PyObject *) self, value); + self->is_running = 0; + if (retval) { + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + } +#endif + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_MethodReturn(PyObject *retval) { + if (unlikely(!retval && !PyErr_Occurred())) { + PyErr_SetNone(PyExc_StopIteration); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { + PyObject *ret; + PyObject *val = NULL; + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen_FetchStopIterationValue(&val); + ret = __Pyx_Coroutine_SendEx(gen, val); + Py_XDECREF(val); + return ret; +} +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + { + if (value == Py_None) + ret = PyIter_Next(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + } + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + retval = __Pyx_Coroutine_FinishDelegation(gen); + } else { + retval = __Pyx_Coroutine_SendEx(gen, value); + } + return __Pyx_Coroutine_MethodReturn(retval); +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + PyObject *retval = NULL; + int err = 0; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + { + PyObject *meth; + gen->is_running = 1; + meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + if (unlikely(!meth)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_WriteUnraisable(yf); + } + PyErr_Clear(); + } else { + retval = PyObject_CallFunction(meth, NULL); + Py_DECREF(meth); + if (!retval) + err = -1; + } + gen->is_running = 0; + } + Py_XDECREF(retval); + return err; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + ret = Py_TYPE(yf)->tp_iternext(yf); + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + return __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_SendEx(gen, Py_None); +} +static PyObject *__Pyx_Coroutine_Close(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *retval, *raised_exception; + PyObject *yf = gen->yieldfrom; + int err = 0; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + retval = __Pyx_Coroutine_SendEx(gen, NULL); + if (retval) { + Py_DECREF(retval); + PyErr_SetString(PyExc_RuntimeError, + "generator ignored GeneratorExit"); + return NULL; + } + raised_exception = PyErr_Occurred(); + if (!raised_exception + || raised_exception == PyExc_StopIteration + || raised_exception == PyExc_GeneratorExit + || PyErr_GivenExceptionMatches(raised_exception, PyExc_GeneratorExit) + || PyErr_GivenExceptionMatches(raised_exception, PyExc_StopIteration)) + { + if (raised_exception) PyErr_Clear(); + Py_INCREF(Py_None); + return Py_None; + } + return NULL; +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *typ; + PyObject *tb = NULL; + PyObject *val = NULL; + PyObject *yf = gen->yieldfrom; + if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + return NULL; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + Py_INCREF(yf); + if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit)) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); + goto throw_here; + } + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + { + PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + gen->is_running = 0; + return NULL; + } + PyErr_Clear(); + __Pyx_Coroutine_Undelegate(gen); + gen->is_running = 0; + goto throw_here; + } + ret = PyObject_CallObject(meth, args); + Py_DECREF(meth); + } + gen->is_running = 0; + Py_DECREF(yf); + if (!ret) { + ret = __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_MethodReturn(ret); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); +} +static int __Pyx_Coroutine_traverse(PyObject *self, visitproc visit, void *arg) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + Py_VISIT(gen->exc_type); + Py_VISIT(gen->exc_value); + Py_VISIT(gen->exc_traceback); + return 0; +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + Py_CLEAR(gen->yieldfrom); + Py_CLEAR(gen->exc_type); + Py_CLEAR(gen->exc_value); + Py_CLEAR(gen->exc_traceback); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label > 0) { + PyObject_GC_Track(self); +#if PY_VERSION_HEX >= 0x030400a1 + if (PyObject_CallFinalizerFromDealloc(self)) +#else + Py_TYPE(gen)->tp_del(self); + if (self->ob_refcnt > 0) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } + __Pyx_Coroutine_clear(self); + PyObject_GC_Del(gen); +} +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *res; + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + if (gen->resume_label <= 0) + return ; +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt == 0); + self->ob_refcnt = 1; +#endif + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + res = __Pyx_Coroutine_Close(self); + if (res == NULL) + PyErr_WriteUnraisable(self); + else + Py_DECREF(res); + __Pyx_ErrRestore(error_type, error_value, error_traceback); +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt > 0); + if (--self->ob_refcnt == 0) { + return; + } + { + Py_ssize_t refcnt = self->ob_refcnt; + _Py_NewReference(self); + self->ob_refcnt = refcnt; + } +#if CYTHON_COMPILING_IN_CPYTHON + assert(PyType_IS_GC(self->ob_type) && + _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); + _Py_DEC_REFTOTAL; +#endif +#ifdef COUNT_ALLOCS + --Py_TYPE(self)->tp_frees; + --Py_TYPE(self)->tp_allocs; +#endif +#endif +} +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_name); + return self->gi_name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = self->gi_name; + Py_INCREF(value); + self->gi_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_qualname); + return self->gi_qualname; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = self->gi_qualname; + Py_INCREF(value); + self->gi_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject* type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (gen == NULL) + return NULL; + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->exc_type = NULL; + gen->exc_value = NULL; + gen->exc_traceback = NULL; + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + PyObject_GC_Track(gen); + return gen; +} + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + int result; + PyObject *globals, *result_obj; + globals = PyDict_New(); if (unlikely(!globals)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_coroutine_type", + #ifdef __Pyx_Coroutine_USED + (PyObject*)__pyx_CoroutineType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_generator_type", + #ifdef __Pyx_Generator_USED + (PyObject*)__pyx_GeneratorType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; + result_obj = PyRun_String(py_code, Py_file_input, globals, globals); + if (unlikely(!result_obj)) goto ignore; + Py_DECREF(result_obj); + Py_DECREF(globals); + return module; +ignore: + Py_XDECREF(globals); + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + py_code++; +#endif + return module; +} + +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) +static PyObject* __Pyx_patch_abc_module(PyObject *module); +static PyObject* __Pyx_patch_abc_module(PyObject *module) { + module = __Pyx_Coroutine_patch_module( + module, "" +"if _cython_generator_type is not None:\n" +" try: Generator = _module.Generator\n" +" except AttributeError: pass\n" +" else: Generator.register(_cython_generator_type)\n" +"if _cython_coroutine_type is not None:\n" +" try: Coroutine = _module.Coroutine\n" +" except AttributeError: pass\n" +" else: Coroutine.register(_cython_coroutine_type)\n" + ); + return module; +} +#endif +static int __Pyx_patch_abc(void) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + static int abc_patched = 0; + if (!abc_patched) { + PyObject *module; + module = PyImport_ImportModule((PY_VERSION_HEX >= 0x03030000) ? "collections.abc" : "collections"); + if (!module) { + PyErr_WriteUnraisable(NULL); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, + ((PY_VERSION_HEX >= 0x03030000) ? + "Cython module failed to register with collections.abc module" : + "Cython module failed to register with collections module"), 1) < 0)) { + return -1; + } + } else { + module = __Pyx_patch_abc_module(module); + abc_patched = 1; + if (unlikely(!module)) + return -1; + Py_DECREF(module); + } + module = PyImport_ImportModule("backports_abc"); + if (module) { + module = __Pyx_patch_abc_module(module); + Py_XDECREF(module); + } + if (!module) { + PyErr_Clear(); + } + } +#else + if (0) __Pyx_Coroutine_patch_module(NULL, NULL); +#endif + return 0; +} + +static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the generator"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the generator"), 0}, + {0, 0, 0, 0, 0} +}; +static PyTypeObject __pyx_GeneratorType_type = { + PyVarObject_HEAD_INIT(0, 0) + "generator", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, + 0, + offsetof(__pyx_CoroutineObject, gi_weakreflist), + 0, + (iternextfunc) __Pyx_Generator_Next, + __pyx_Generator_methods, + __pyx_Generator_memberlist, + __pyx_Generator_getsets, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if PY_VERSION_HEX >= 0x030400a1 + __Pyx_Coroutine_del, +#endif +}; +static int __pyx_Generator_init(void) { + __pyx_GeneratorType_type.tp_getattro = PyObject_GenericGetAttr; + __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; + __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); + if (unlikely(!__pyx_GeneratorType)) { + return -1; + } + return 0; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0) + goto bad; + } + tmp.fp = f; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/mumps.cpd b/mumps/src/mumps_INT32_COMPLEX128.pxd similarity index 64% rename from mumps/src/mumps.cpd rename to mumps/src/mumps_INT32_COMPLEX128.pxd index 6c94534..a68d06e 100644 --- a/mumps/src/mumps.cpd +++ b/mumps/src/mumps_INT32_COMPLEX128.pxd @@ -23,14 +23,14 @@ cdef extern from "mumps_c_types.h": ctypedef mumps_double_complex ZMUMPS_COMPLEX ctypedef double ZMUMPS_REAL -cdef extern from "@type|generic_to_mumps_type@mumps_c.h": - ctypedef struct @type|generic_to_mumps_type|upper@MUMPS_STRUC_C: +cdef extern from "zmumps_c.h": + ctypedef struct ZMUMPS_STRUC_C: MUMPS_INT sym, par, job MUMPS_INT comm_fortran # Fortran communicator MUMPS_INT icntl[40] MUMPS_INT keep[500] - @type|generic_to_mumps_type|upper@MUMPS_REAL cntl[15] - @type|generic_to_mumps_type|upper@MUMPS_REAL dkeep[130]; + ZMUMPS_REAL cntl[15] + ZMUMPS_REAL dkeep[130]; MUMPS_INT8 keep8[150]; MUMPS_INT n @@ -42,19 +42,19 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": MUMPS_INT nz MUMPS_INT *irn MUMPS_INT *jcn - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *a + ZMUMPS_COMPLEX *a # Distributed entry MUMPS_INT nz_loc MUMPS_INT *irn_loc MUMPS_INT *jcn_loc - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *a_loc + ZMUMPS_COMPLEX *a_loc # Element entry MUMPS_INT nelt MUMPS_INT *eltptr MUMPS_INT *eltvar - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *a_elt + ZMUMPS_COMPLEX *a_elt # Ordering, if given by user MUMPS_INT *perm_in @@ -64,17 +64,17 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": MUMPS_INT *uns_perm # column permutation # Scaling (input only in this version) - @type|generic_to_mumps_type|upper@MUMPS_REAL *colsca - @type|generic_to_mumps_type|upper@MUMPS_REAL *rowsca + ZMUMPS_REAL *colsca + ZMUMPS_REAL *rowsca MUMPS_INT colsca_from_mumps; MUMPS_INT rowsca_from_mumps; # RHS, solution, ouptput data and statistics - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *rhs - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *redrhs - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *rhs_sparse - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *sol_loc + ZMUMPS_COMPLEX *rhs + ZMUMPS_COMPLEX *redrhs + ZMUMPS_COMPLEX *rhs_sparse + ZMUMPS_COMPLEX *sol_loc MUMPS_INT *irhs_sparse MUMPS_INT *irhs_ptr MUMPS_INT *isol_loc @@ -83,8 +83,8 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": MUMPS_INT mblock, nblock, nprow, npcol MUMPS_INT info[40] MUMPS_INT infog[40] - @type|generic_to_mumps_type|upper@MUMPS_REAL rinfo[40] - @type|generic_to_mumps_type|upper@MUMPS_REAL rinfog[40] + ZMUMPS_REAL rinfo[40] + ZMUMPS_REAL rinfog[40] # Null space MUMPS_INT deficiency @@ -94,11 +94,11 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": # Schur MUMPS_INT size_schur MUMPS_INT *listvar_schur - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *schur + ZMUMPS_COMPLEX *schur # Internal parameters MUMPS_INT instance_number - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *wk_user + ZMUMPS_COMPLEX *wk_user char *version_number # For out-of-core @@ -108,7 +108,7 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": char *write_problem MUMPS_INT lwk_user - cdef void @type|generic_to_mumps_type@mumps_c(@type|generic_to_mumps_type|upper@MUMPS_STRUC_C *) + cdef void zmumps_c(ZMUMPS_STRUC_C *) cdef class mumps_int_array: """ @@ -122,21 +122,21 @@ cdef class mumps_int_array: cdef get_array(self, MUMPS_INT * array, int ub = ?) -cdef class @type|generic_to_mumps_type@mumps_real_array: +cdef class zmumps_real_array: """ Internal classes to use x[i] = value and x[i] setters and getters Real version. """ cdef: - @type|generic_to_mumps_type|upper@MUMPS_REAL * array + ZMUMPS_REAL * array int ub - cdef get_array(self, @type|generic_to_mumps_type|upper@MUMPS_REAL * array, int ub = ?) + cdef get_array(self, ZMUMPS_REAL * array, int ub = ?) cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) -cdef class BaseMUMPSSolver_@index@_@type@: +cdef class BaseMUMPSSolver_INT32_COMPLEX128: cdef: MUMPS_INT nrow @@ -144,20 +144,20 @@ cdef class BaseMUMPSSolver_@index@_@type@: MUMPS_INT nnz # MUMPS - @type|generic_to_mumps_type|upper@MUMPS_STRUC_C params + ZMUMPS_STRUC_C params # internal classes for getters and setters mumps_int_array icntl mumps_int_array info mumps_int_array infog - @type|generic_to_mumps_type@mumps_real_array cntl - @type|generic_to_mumps_type@mumps_real_array rinfo - @type|generic_to_mumps_type@mumps_real_array rinfog + zmumps_real_array cntl + zmumps_real_array rinfo + zmumps_real_array rinfog MUMPS_INT * a_row MUMPS_INT * a_col - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * a_val + ZMUMPS_COMPLEX * a_val bint analyzed bint factorized @@ -170,7 +170,7 @@ cdef class BaseMUMPSSolver_@index@_@type@: cdef get_data_pointers(self, MUMPS_INT * a_row, MUMPS_INT * a_col, - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * a_val) + ZMUMPS_COMPLEX * a_val) cdef initialize_mumps_struct(self, comm_fortran, sym) @@ -178,10 +178,9 @@ cdef class BaseMUMPSSolver_@index@_@type@: cdef set_centralized_assembled_matrix(self) - cdef solve_dense(self, @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * rhs, + cdef solve_dense(self, ZMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs) cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * rhs_val, + ZMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * x, MUMPS_INT x_length) - + ZMUMPS_COMPLEX * x, MUMPS_INT x_length) diff --git a/mumps/src/mumps.cpx b/mumps/src/mumps_INT32_COMPLEX128.pyx similarity index 86% rename from mumps/src/mumps.cpx rename to mumps/src/mumps_INT32_COMPLEX128.pyx index c7fb707..ea09557 100644 --- a/mumps/src/mumps.cpx +++ b/mumps/src/mumps_INT32_COMPLEX128.pyx @@ -51,9 +51,9 @@ Each MUMPS_STRUC_C is specialized and prefixed by a letter: - CMUMPS_STRUC_C: simple complex; - ZMUMPS_STRUC_C: double complex. -In MUMPSContext_@index@_@type@, (S,D,C,Z)mumps_c() is called by self.mumps_call(). +In MUMPSContext_INT32_COMPLEX128, (S,D,C,Z)mumps_c() is called by self.mumps_call(). -<@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> can be used for **ALL** four types. + can be used for **ALL** four types. Solve: ------ @@ -123,14 +123,14 @@ cdef extern from "mumps_c_types.h": ctypedef mumps_double_complex ZMUMPS_COMPLEX ctypedef double ZMUMPS_REAL -cdef extern from "@type|generic_to_mumps_type@mumps_c.h": - ctypedef struct @type|generic_to_mumps_type|upper@MUMPS_STRUC_C: +cdef extern from "zmumps_c.h": + ctypedef struct ZMUMPS_STRUC_C: MUMPS_INT sym, par, job MUMPS_INT comm_fortran # Fortran communicator MUMPS_INT icntl[40] MUMPS_INT keep[500] - @type|generic_to_mumps_type|upper@MUMPS_REAL cntl[15] - @type|generic_to_mumps_type|upper@MUMPS_REAL dkeep[130]; + ZMUMPS_REAL cntl[15] + ZMUMPS_REAL dkeep[130]; MUMPS_INT8 keep8[150]; MUMPS_INT n @@ -142,19 +142,19 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": MUMPS_INT nz MUMPS_INT *irn MUMPS_INT *jcn - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *a + ZMUMPS_COMPLEX *a # Distributed entry MUMPS_INT nz_loc MUMPS_INT *irn_loc MUMPS_INT *jcn_loc - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *a_loc + ZMUMPS_COMPLEX *a_loc # Element entry MUMPS_INT nelt MUMPS_INT *eltptr MUMPS_INT *eltvar - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *a_elt + ZMUMPS_COMPLEX *a_elt # Ordering, if given by user MUMPS_INT *perm_in @@ -164,17 +164,17 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": MUMPS_INT *uns_perm # column permutation # Scaling (input only in this version) - @type|generic_to_mumps_type|upper@MUMPS_REAL *colsca - @type|generic_to_mumps_type|upper@MUMPS_REAL *rowsca + ZMUMPS_REAL *colsca + ZMUMPS_REAL *rowsca MUMPS_INT colsca_from_mumps; MUMPS_INT rowsca_from_mumps; # RHS, solution, ouptput data and statistics - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *rhs - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *redrhs - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *rhs_sparse - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *sol_loc + ZMUMPS_COMPLEX *rhs + ZMUMPS_COMPLEX *redrhs + ZMUMPS_COMPLEX *rhs_sparse + ZMUMPS_COMPLEX *sol_loc MUMPS_INT *irhs_sparse MUMPS_INT *irhs_ptr MUMPS_INT *isol_loc @@ -183,8 +183,8 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": MUMPS_INT mblock, nblock, nprow, npcol MUMPS_INT info[40] MUMPS_INT infog[40] - @type|generic_to_mumps_type|upper@MUMPS_REAL rinfo[40] - @type|generic_to_mumps_type|upper@MUMPS_REAL rinfog[40] + ZMUMPS_REAL rinfo[40] + ZMUMPS_REAL rinfog[40] # Null space MUMPS_INT deficiency @@ -194,11 +194,11 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": # Schur MUMPS_INT size_schur MUMPS_INT *listvar_schur - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *schur + ZMUMPS_COMPLEX *schur # Internal parameters MUMPS_INT instance_number - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX *wk_user + ZMUMPS_COMPLEX *wk_user char *version_number # For out-of-core @@ -208,7 +208,7 @@ cdef extern from "@type|generic_to_mumps_type@mumps_c.h": char *write_problem MUMPS_INT lwk_user - cdef void @type|generic_to_mumps_type@mumps_c(@type|generic_to_mumps_type|upper@MUMPS_STRUC_C *) + cdef void zmumps_c(ZMUMPS_STRUC_C *) # MUMPS possible ordering methods orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, @@ -271,7 +271,7 @@ cdef class mumps_int_array: def __setitem__(self, key, value): self.array[key - 1] = value -cdef class @type|generic_to_mumps_type@mumps_real_array: +cdef class zmumps_real_array: """ Internal classes to use x[i] = value and x[i] setters and getters @@ -281,7 +281,7 @@ cdef class @type|generic_to_mumps_type@mumps_real_array: def __cinit__(self): pass - cdef get_array(self, @type|generic_to_mumps_type|upper@MUMPS_REAL * array, int ub = 40): + cdef get_array(self, ZMUMPS_REAL * array, int ub = 40): """ Args: ub: upper bound. @@ -300,17 +300,7 @@ cdef class @type|generic_to_mumps_type@mumps_real_array: def __setitem__(self, key, value): self.array[key - 1] = value -{% if type == 'FLOAT32' %} -{% elif type == 'FLOAT64' %} - -{% elif type == 'COMPLEX64' %} - -{% elif type == 'COMPLEX128' %} - -{% else %} -YOU HAVE TO CAST YOUR NEW MUMPS TYPE HERE -{% endif %} cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): cdef: @@ -320,7 +310,7 @@ cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): a[i] += 1 # MUMPS CONTEXT -cdef class BaseMUMPSSolver_@index@_@type@: +cdef class BaseMUMPSSolver_INT32_COMPLEX128: """ Base MUMPS Context. @@ -390,22 +380,22 @@ cdef class BaseMUMPSSolver_@index@_@type@: self.infog.get_array(self.params.infog) # real/complex control parameters - self.cntl = @type|generic_to_mumps_type@mumps_real_array() + self.cntl = zmumps_real_array() self.cntl.get_array(self.params.cntl) # real/complex information parameters - self.rinfo = @type|generic_to_mumps_type@mumps_real_array() + self.rinfo = zmumps_real_array() self.rinfo.get_array(self.params.rinfo) # real/complex information parameters - self.rinfog = @type|generic_to_mumps_type@mumps_real_array() + self.rinfog = zmumps_real_array() self.rinfog.get_array(self.params.rinfog) cdef get_data_pointers(self, MUMPS_INT * a_row, MUMPS_INT * a_col, - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * a_val): + ZMUMPS_COMPLEX * a_val): """ Get elements of A and their positions and transfer them to MUMPS internal structure. @@ -419,7 +409,7 @@ cdef class BaseMUMPSSolver_@index@_@type@: self.a_row = a_row self.a_col = a_col - self.a_val = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> a_val + self.a_val = a_val # transform c index arrays to fortran arrays c_to_fortran_index_array(self.a_row, self.nnz) @@ -438,7 +428,7 @@ cdef class BaseMUMPSSolver_@index@_@type@: self.params.irn = self.a_row self.params.jcn = self.a_col - self.params.a = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> self.a_val + self.params.a = self.a_val def __dealloc__(self): @@ -630,35 +620,35 @@ cdef class BaseMUMPSSolver_@index@_@type@: property a: def __get__(self): return self.params.a - def __set__(self, long value): self.params.a = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.a = value property a_loc: def __get__(self): return self.params.a_loc - def __set__(self, long value): self.params.a_loc = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.a_loc = value property a_elt: def __get__(self): return self.params.a_elt - def __set__(self, long value): self.params.a_elt = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.a_elt = value property colsca: def __get__(self): return self.params.colsca - def __set__(self, long value): self.params.colsca = <@type|generic_to_mumps_type|upper@MUMPS_REAL*> value + def __set__(self, long value): self.params.colsca = value property rowsca: def __get__(self): return self.params.rowsca - def __set__(self, long value): self.params.rowsca = <@type|generic_to_mumps_type|upper@MUMPS_REAL*> value + def __set__(self, long value): self.params.rowsca = value property rhs: def __get__(self): return self.params.rhs - def __set__(self, long value): self.params.rhs = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.rhs = value property redrhs: def __get__(self): return self.params.redrhs - def __set__(self, long value): self.params.redrhs = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.redrhs = value property rhs_sparse: def __get__(self): return self.params.rhs_sparse - def __set__(self, long value): self.params.rhs_sparse = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.rhs_sparse = value property sol_loc: def __get__(self): return self.params.sol_loc - def __set__(self, long value): self.params.sol_loc = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.sol_loc = value property rinfo: def __get__(self): @@ -670,18 +660,18 @@ cdef class BaseMUMPSSolver_@index@_@type@: property schur: def __get__(self): return self.params.schur - def __set__(self, long value): self.params.schur = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.schur = value property wk_user: def __get__(self): return self.params.wk_user - def __set__(self, long value): self.params.wk_user = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX*> value + def __set__(self, long value): self.params.wk_user = value # MUMPS CALL cdef mumps_call(self): """ Call to Xmumps_c(XMUMPS_STRUC_C). """ - @type|generic_to_mumps_type@mumps_c(&self.params) + zmumps_c(&self.params) def set_silent(self): @@ -777,7 +767,7 @@ cdef class BaseMUMPSSolver_@index@_@type@: self.factorized = True # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) - cdef solve_dense(self, @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): + cdef solve_dense(self, ZMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): """ Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` @@ -791,13 +781,13 @@ cdef class BaseMUMPSSolver_@index@_@type@: """ self.params.nrhs = nrhs self.params.lrhs = rhs_length - self.params.rhs = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *>rhs + self.params.rhs = rhs self.params.job = 3 # solve self.mumps_call() cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, - @type|generic_to_mumps_type|upper@MUMPS_COMPLEX * x, MUMPS_INT x_length): + ZMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + ZMUMPS_COMPLEX * x, MUMPS_INT x_length): """ Solve a linear system after the LU (or LDL^t) factorization has previously been performed by `factorize` @@ -817,13 +807,13 @@ cdef class BaseMUMPSSolver_@index@_@type@: self.params.nz_rhs = rhs_nnz self.params.nrhs = nrhs # nrhs -1 ? - self.params.rhs_sparse = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> rhs_val + self.params.rhs_sparse = rhs_val self.params.irhs_sparse = rhs_row_ind self.params.irhs_ptr = rhs_col_ptr # MUMPS places the solution(s) of the linear system in its dense rhs... self.params.lrhs = x_length - self.params.rhs = <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> x + self.params.rhs = x self.params.job = 3 # solve self.icntl[20] = 1 # tell solver rhs is sparse @@ -873,7 +863,7 @@ cdef class BaseMUMPSSolver_@index@_@type@: else: nrhs = rhs_shape[1] - self.solve_dense(<@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : @@ -889,11 +879,11 @@ cdef class BaseMUMPSSolver_@index@_@type@: x_length = self.nrow rhs_nnz = rhs_val.size - x = np.zeros([self.nrow, nrhs], dtype=np.@type|lower@) + x = np.zeros([self.nrow, nrhs], dtype=np.complex128) self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), - <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> cnp.PyArray_DATA(rhs_val), - rhs_nnz, nrhs, <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> cnp.PyArray_DATA(x), x_length) + cnp.PyArray_DATA(rhs_val), + rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) else: raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') @@ -948,10 +938,10 @@ cdef class BaseMUMPSSolver_@index@_@type@: else: self.cntl[2] = tol - self.solve_dense(<@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # reset to default values self.icntl[10] = 0 self.cntl[2] = -1 - return x + return x \ No newline at end of file diff --git a/mumps/src/mumps_INT32_COMPLEX64.c b/mumps/src/mumps_INT32_COMPLEX64.c new file mode 100644 index 0000000..571e0fe --- /dev/null +++ b/mumps/src/mumps_INT32_COMPLEX64.c @@ -0,0 +1,19896 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__mumps_INT32_COMPLEX64 +#define __PYX_HAVE_API__mumps__src__mumps_INT32_COMPLEX64 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "cmumps_c.h" +#include "stdint.h" +#include "pythread.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/mumps_INT32_COMPLEX64.pyx", + "__init__.pxd", + "type.pxd", + "bool.pxd", + "complex.pxd", +}; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve; +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class cmumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":135 + * int ub + * + * cdef get_array(self, CMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":113 + * cdef void cmumps_c(CMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class cmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_vtab; + CMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_COMPLEX64: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + CMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + CMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve { + PyObject_HEAD + PyObject *__pyx_v_kwargs; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr { + PyObject_HEAD + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *__pyx_outer_scope; + PyObject *__pyx_v_arg; +}; + + + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":245 + * + * # MUMPS HELPERS + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":274 + * self.array[key - 1] = value + * + * cdef class cmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *, CMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":313 + * + * # MUMPS CONTEXT + * cdef class BaseMUMPSSolver_INT32_COMPLEX64: # <<<<<<<<<<<<<< + * """ + * Base MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, MUMPS_INT *, MUMPS_INT *, CMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, CMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, MUMPS_INT *, MUMPS_INT *, CMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, CMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +static CYTHON_INLINE PyObject* __Pyx_decode_bytes( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string), + start, stop, encoding, errors, decode_func); +} + +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\ + PyObject_RichCompare(op1, op2, Py_EQ) + #endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); + +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +#include + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *); +typedef struct { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject *type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname); +static int __Pyx_Coroutine_clear(PyObject *self); +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue); +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue) +#endif + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +static int __Pyx_patch_abc(void); + +#define __Pyx_Generator_USED +static PyTypeObject *__pyx_GeneratorType = 0; +#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_New(body, closure, name, qualname)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, closure, name, qualname) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(void); + +static int __Pyx_check_binary_version(void); + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self, CMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_get_data_pointers(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, CMUMPS_COMPLEX *__pyx_v_a_val); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mumps_call(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_solve_dense(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, CMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_solve_sparse(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, CMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, CMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython.version' */ + +/* Module declarations from 'cpython.exc' */ + +/* Module declarations from 'cpython.module' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'cpython.tuple' */ + +/* Module declarations from 'cpython.list' */ + +/* Module declarations from 'cpython.sequence' */ + +/* Module declarations from 'cpython.mapping' */ + +/* Module declarations from 'cpython.iterator' */ + +/* Module declarations from 'cpython.number' */ + +/* Module declarations from 'cpython.int' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.bool' */ +static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; + +/* Module declarations from 'cpython.long' */ + +/* Module declarations from 'cpython.float' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.complex' */ +static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; + +/* Module declarations from 'cpython.string' */ + +/* Module declarations from 'cpython.unicode' */ + +/* Module declarations from 'cpython.dict' */ + +/* Module declarations from 'cpython.instance' */ + +/* Module declarations from 'cpython.function' */ + +/* Module declarations from 'cpython.method' */ + +/* Module declarations from 'cpython.weakref' */ + +/* Module declarations from 'cpython.getargs' */ + +/* Module declarations from 'cpython.pythread' */ + +/* Module declarations from 'cpython.pystate' */ + +/* Module declarations from 'cpython.cobject' */ + +/* Module declarations from 'cpython.oldbuffer' */ + +/* Module declarations from 'cpython.set' */ + +/* Module declarations from 'cpython.bytes' */ + +/* Module declarations from 'cpython.pycapsule' */ + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'libc.stdint' */ + +/* Module declarations from 'mumps.src.mumps_INT32_COMPLEX64' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr = 0; +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_c_to_fortran_index_array(MUMPS_INT *, MUMPS_INT); /*proto*/ +#define __Pyx_MODULE_NAME "mumps.src.mumps_INT32_COMPLEX64" +int __pyx_module_is_main_mumps__src__mumps_INT32_COMPLEX64 = 0; + +/* Implementation of 'mumps.src.mumps_INT32_COMPLEX64' */ +static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_IndexError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_amd[] = "amd"; +static char __pyx_k_amf[] = "amf"; +static char __pyx_k_doc[] = "__doc__"; +static char __pyx_k_get[] = "get"; +static char __pyx_k_msg[] = "msg"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_rhs[] = "rhs"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_tol[] = "tol"; +static char __pyx_k_args[] = "args"; +static char __pyx_k_auto[] = "auto"; +static char __pyx_k_copy[] = "copy"; +static char __pyx_k_init[] = "__init__"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_ndim[] = "ndim"; +static char __pyx_k_pord[] = "pord"; +static char __pyx_k_qamd[] = "qamd"; +static char __pyx_k_self[] = "self"; +static char __pyx_k_send[] = "send"; +static char __pyx_k_size[] = "size"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_time[] = "time"; +static char __pyx_k_clock[] = "clock"; +static char __pyx_k_close[] = "close"; +static char __pyx_k_dtype[] = "dtype"; +static char __pyx_k_error[] = "error"; +static char __pyx_k_infog[] = "infog"; +static char __pyx_k_metis[] = "metis"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_shape[] = "shape"; +static char __pyx_k_throw[] = "throw"; +static char __pyx_k_zeros[] = "zeros"; +static char __pyx_k_format[] = "format"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_module[] = "__module__"; +static char __pyx_k_nitref[] = "nitref"; +static char __pyx_k_scotch[] = "scotch"; +static char __pyx_k_analyze[] = "analyze"; +static char __pyx_k_genexpr[] = "genexpr"; +static char __pyx_k_prepare[] = "__prepare__"; +static char __pyx_k_rhs_val[] = "rhs_val"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ordering[] = "ordering"; +static char __pyx_k_qualname[] = "__qualname__"; +static char __pyx_k_TypeError[] = "TypeError"; +static char __pyx_k_complex64[] = "complex64"; +static char __pyx_k_factorize[] = "factorize"; +static char __pyx_k_metaclass[] = "__metaclass__"; +static char __pyx_k_orderings[] = "orderings"; +static char __pyx_k_pivot_tol[] = "pivot_tol"; +static char __pyx_k_IndexError[] = "IndexError"; +static char __pyx_k_MUMPSError[] = "MUMPSError"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_refinement[] = "refinement."; +static char __pyx_k_set_silent[] = "set_silent"; +static char __pyx_k_MUMPS_error[] = "{}. (MUMPS error {})"; +static char __pyx_k_rhs_col_ptr[] = "rhs_col_ptr"; +static char __pyx_k_rhs_row_ind[] = "rhs_row_ind"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_user_defined[] = "user-defined"; +static char __pyx_k_ordering_name[] = "ordering_name"; +static char __pyx_k_asfortranarray[] = "asfortranarray"; +static char __pyx_k_error_messages[] = "error_messages"; +static char __pyx_k_SolveStatistics[] = "SolveStatistics"; +static char __pyx_k_transpose_solve[] = "transpose_solve"; +static char __pyx_k_MUMPSError___init[] = "MUMPSError.__init__"; +static char __pyx_k_Not_enough_memory[] = "Not enough memory"; +static char __pyx_k_AnalysisStatistics[] = "AnalysisStatistics"; +static char __pyx_k_solve_locals_genexpr[] = "solve..genexpr"; +static char __pyx_k_MUMPS_index_must_be_d[] = "MUMPS index must be <= %d"; +static char __pyx_k_mumps_mumps_statistics[] = "mumps.mumps_statistics"; +static char __pyx_k_FactorizationStatistics[] = "FactorizationStatistics"; +static char __pyx_k_MUMPS_failed_with_error[] = "MUMPS failed with error {}."; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_Matrix_is_numerically_singular[] = "Matrix is numerically singular"; +static char __pyx_k_This_is_the_base_class_for_the[] = "\nThis is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home)\n\n"; +static char __pyx_k_Matrix_is_singular_in_structure[] = "Matrix is singular in structure"; +static char __pyx_k_The_authors_of_MUMPS_would_like[] = "The authors of MUMPS would like to hear about this"; +static char __pyx_k_Users_syarra_work_VirtualEnvs_n[] = "/Users/syarra/work/VirtualEnvs/nlpy_new/programs/MUMPS.py/mumps/src/mumps_INT32_COMPLEX64.pyx"; +static char __pyx_k_mumps_src_mumps_INT32_COMPLEX64[] = "mumps.src.mumps_INT32_COMPLEX64"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_MUMPS_index_must_be_1_Fortran_st[] = "MUMPS index must be >= 1 (Fortran style)"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_Not_enough_memory_during_analysi[] = "Not enough memory during analysis phase"; +static char __pyx_k_Only_one_dense_rhs_is_allowed_fo[] = "Only one dense rhs is allowed for performing an iterative"; +static char __pyx_k_Right_hand_side_has_wrong_sizeAt[] = "Right hand side has wrong sizeAttempting to solve the linear system, where A is of size (%d, %d) and rhs is of size (%g)"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_rhs_dense_arrays_must_be_an_NumP[] = "rhs dense arrays must be an NumPy array"; +static char __pyx_k_rhs_not_given_in_the_right_forma[] = "rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_n_s_AnalysisStatistics; +static PyObject *__pyx_n_s_FactorizationStatistics; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_n_s_MUMPSError; +static PyObject *__pyx_n_s_MUMPSError___init; +static PyObject *__pyx_kp_s_MUMPS_error; +static PyObject *__pyx_kp_s_MUMPS_failed_with_error; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_d; +static PyObject *__pyx_kp_s_Matrix_is_numerically_singular; +static PyObject *__pyx_kp_s_Matrix_is_singular_in_structure; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_kp_s_Not_enough_memory; +static PyObject *__pyx_kp_s_Not_enough_memory_during_analysi; +static PyObject *__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo; +static PyObject *__pyx_kp_s_Right_hand_side_has_wrong_sizeAt; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_SolveStatistics; +static PyObject *__pyx_kp_s_The_authors_of_MUMPS_would_like; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Users_syarra_work_VirtualEnvs_n; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_amd; +static PyObject *__pyx_n_s_amf; +static PyObject *__pyx_n_s_analyze; +static PyObject *__pyx_n_s_args; +static PyObject *__pyx_n_s_asfortranarray; +static PyObject *__pyx_n_s_auto; +static PyObject *__pyx_n_s_clock; +static PyObject *__pyx_n_s_close; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_complex64; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_error_messages; +static PyObject *__pyx_n_s_factorize; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_genexpr; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_infog; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_metis; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_msg; +static PyObject *__pyx_n_s_mumps_mumps_statistics; +static PyObject *__pyx_n_s_mumps_src_mumps_INT32_COMPLEX64; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_nitref; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_ordering; +static PyObject *__pyx_n_s_ordering_name; +static PyObject *__pyx_n_s_orderings; +static PyObject *__pyx_n_s_pivot_tol; +static PyObject *__pyx_n_s_pord; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_qamd; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_kp_s_refinement; +static PyObject *__pyx_n_s_rhs; +static PyObject *__pyx_n_s_rhs_col_ptr; +static PyObject *__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP; +static PyObject *__pyx_kp_s_rhs_not_given_in_the_right_forma; +static PyObject *__pyx_n_s_rhs_row_ind; +static PyObject *__pyx_n_s_rhs_val; +static PyObject *__pyx_n_s_scotch; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_n_s_send; +static PyObject *__pyx_n_s_set_silent; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_size; +static PyObject *__pyx_n_s_solve_locals_genexpr; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_throw; +static PyObject *__pyx_n_s_time; +static PyObject *__pyx_n_s_tol; +static PyObject *__pyx_n_s_transpose_solve; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_kp_s_user_defined; +static PyObject *__pyx_n_s_verbose; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64___cinit__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose); /* proto */ +static void __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2__dealloc__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8analyzed___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10factorized___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5icntl___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4info___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5infog___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_14version_number___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4cntl___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5rinfo___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rinfog___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4set_silent(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6analyze(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_ordering); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8factorize(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5solve_genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10solve(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12refine(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_float_0_01; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_5; +static PyObject *__pyx_int_6; +static PyObject *__pyx_int_7; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_int_neg_5; +static PyObject *__pyx_int_neg_6; +static PyObject *__pyx_int_neg_7; +static PyObject *__pyx_int_neg_8; +static PyObject *__pyx_int_neg_9; +static PyObject *__pyx_int_neg_10; +static PyObject *__pyx_int_neg_11; +static PyObject *__pyx_int_neg_12; +static PyObject *__pyx_int_neg_13; +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_codeobj__14; + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError_1__init__ = {"__init__", (PyCFunction)__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_infog = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_infog,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_infog)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_infog = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError___init__(__pyx_self, __pyx_v_self, __pyx_v_infog); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog) { + PyObject *__pyx_v_msg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":235 + * class MUMPSError(RuntimeError): + * def __init__(self, infog): + * self.error = infog[1] # <<<<<<<<<<<<<< + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_infog, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_error, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":237 + * self.error = infog[1] + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( # <<<<<<<<<<<<<< + * error_messages[self.error], self.error) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":238 + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) # <<<<<<<<<<<<<< + * else: + * msg = "MUMPS failed with error {}.".format(self.error) + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + goto __pyx_L3; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":240 + * error_messages[self.error], self.error) + * else: + * msg = "MUMPS failed with error {}.".format(self.error) # <<<<<<<<<<<<<< + * + * RuntimeError.__init__(self, msg) + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_failed_with_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_6) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":242 + * msg = "MUMPS failed with error {}.".format(self.error) + * + * RuntimeError.__init__(self, msg) # <<<<<<<<<<<<<< + * + * # MUMPS HELPERS + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_builtin_RuntimeError, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_self); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_msg); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":252 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array___cinit__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":260 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":261 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_2__getitem__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":267 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":269 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.mumps_int_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_4__setitem__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":272 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * cdef class cmumps_real_array: + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.mumps_int_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":281 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array___cinit__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":284 + * pass + * + * cdef get_array(self, CMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self, CMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":289 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":290 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":284 + * pass + * + * cdef get_array(self, CMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_2__getitem__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":296 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":298 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.cmumps_real_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_4__setitem__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + CMUMPS_REAL __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":301 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_value); if (unlikely((__pyx_t_1 == (CMUMPS_REAL)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.cmumps_real_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_c_to_fortran_index_array(MUMPS_INT *__pyx_v_a, MUMPS_INT __pyx_v_a_size) { + MUMPS_INT __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + MUMPS_INT __pyx_t_2; + __Pyx_RefNannySetupContext("c_to_fortran_index_array", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":309 + * MUMPS_INT i + * + * for i from 0 <= i < a_size: # <<<<<<<<<<<<<< + * a[i] += 1 + * + */ + __pyx_t_1 = __pyx_v_a_size; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":310 + * + * for i from 0 <= i < a_size: + * a[i] += 1 # <<<<<<<<<<<<<< + * + * # MUMPS CONTEXT + */ + __pyx_t_2 = __pyx_v_i; + (__pyx_v_a[__pyx_t_2]) = ((__pyx_v_a[__pyx_t_2]) + 1); + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + MUMPS_INT __pyx_v_n; + MUMPS_INT __pyx_v_nnz; + PyObject *__pyx_v_comm_fortran = 0; + PyObject *__pyx_v_sym = 0; + PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":324 + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64___cinit__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64___cinit__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":333 + * verbose: a boolean to turn on or off the verbosity of MUMPS + * """ + * self.nrow = n # <<<<<<<<<<<<<< + * self.ncol = n + * self.nnz = nnz + */ + __pyx_v_self->nrow = __pyx_v_n; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":334 + * """ + * self.nrow = n + * self.ncol = n # <<<<<<<<<<<<<< + * self.nnz = nnz + * + */ + __pyx_v_self->ncol = __pyx_v_n; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":335 + * self.nrow = n + * self.ncol = n + * self.nnz = nnz # <<<<<<<<<<<<<< + * + * assert self.ncol == self.nrow + */ + __pyx_v_self->nnz = __pyx_v_nnz; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":337 + * self.nnz = nnz + * + * assert self.ncol == self.nrow # <<<<<<<<<<<<<< + * + * self.initialize_mumps_struct(comm_fortran, sym) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_self->ncol == __pyx_v_self->nrow) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":339 + * assert self.ncol == self.nrow + * + * self.initialize_mumps_struct(comm_fortran, sym) # <<<<<<<<<<<<<< + * + * # `initialize_mumps_struct` **must** be called before assigning + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->initialize_mumps_struct(__pyx_v_self, __pyx_v_comm_fortran, __pyx_v_sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":343 + * # `initialize_mumps_struct` **must** be called before assigning + * # a value to n (size of the matrix) + * self.params.n = self.nrow # <<<<<<<<<<<<<< + * + * self.analyzed = False + */ + __pyx_v_self->params.n = ((MUMPS_INT)__pyx_v_self->nrow); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":345 + * self.params.n = self.nrow + * + * self.analyzed = False # <<<<<<<<<<<<<< + * self.factorized = False + * self.out_of_core = False + */ + __pyx_v_self->analyzed = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":346 + * + * self.analyzed = False + * self.factorized = False # <<<<<<<<<<<<<< + * self.out_of_core = False + * + */ + __pyx_v_self->factorized = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":347 + * self.analyzed = False + * self.factorized = False + * self.out_of_core = False # <<<<<<<<<<<<<< + * + * if not verbose: + */ + __pyx_v_self->out_of_core = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = ((!__pyx_t_2) != 0); + if (__pyx_t_3) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":350 + * + * if not verbose: + * self.set_silent() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_silent); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("initialize_mumps_struct", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":362 + * sym: a boolean indicating if A is a symmetric matrix or not + * """ + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.params.sym = sym + * self.params.par = 1 + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":363 + * """ + * self.params.job = -1 + * self.params.sym = sym # <<<<<<<<<<<<<< + * self.params.par = 1 + * + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_sym); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":364 + * self.params.job = -1 + * self.params.sym = sym + * self.params.par = 1 # <<<<<<<<<<<<<< + * + * self.params.comm_fortran = comm_fortran + */ + __pyx_v_self->params.par = 1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":366 + * self.params.par = 1 + * + * self.params.comm_fortran = comm_fortran # <<<<<<<<<<<<<< + * + * self.mumps_call() + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_comm_fortran); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":368 + * self.params.comm_fortran = comm_fortran + * + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # integer control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":371 + * + * # integer control parameters + * self.icntl = mumps_int_array() # <<<<<<<<<<<<<< + * self.icntl.get_array(self.params.icntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 371; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->icntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_v_self->icntl = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":372 + * # integer control parameters + * self.icntl = mumps_int_array() + * self.icntl.get_array(self.params.icntl) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_v_self->icntl->__pyx_vtab)->get_array(__pyx_v_self->icntl, __pyx_v_self->params.icntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":375 + * + * # integer information parameters + * self.info = mumps_int_array() # <<<<<<<<<<<<<< + * self.info.get_array(self.params.info) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->info); + __Pyx_DECREF(((PyObject *)__pyx_v_self->info)); + __pyx_v_self->info = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":376 + * # integer information parameters + * self.info = mumps_int_array() + * self.info.get_array(self.params.info) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_v_self->info->__pyx_vtab)->get_array(__pyx_v_self->info, __pyx_v_self->params.info, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":379 + * + * # integer information parameters + * self.infog = mumps_int_array() # <<<<<<<<<<<<<< + * self.infog.get_array(self.params.infog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->infog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->infog)); + __pyx_v_self->infog = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":380 + * # integer information parameters + * self.infog = mumps_int_array() + * self.infog.get_array(self.params.infog) # <<<<<<<<<<<<<< + * + * # real/complex control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)__pyx_v_self->infog->__pyx_vtab)->get_array(__pyx_v_self->infog, __pyx_v_self->params.infog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":383 + * + * # real/complex control parameters + * self.cntl = cmumps_real_array() # <<<<<<<<<<<<<< + * self.cntl.get_array(self.params.cntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->cntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_v_self->cntl = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":384 + * # real/complex control parameters + * self.cntl = cmumps_real_array() + * self.cntl.get_array(self.params.cntl) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_v_self->cntl->__pyx_vtab)->get_array(__pyx_v_self->cntl, __pyx_v_self->params.cntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 384; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":387 + * + * # real/complex information parameters + * self.rinfo = cmumps_real_array() # <<<<<<<<<<<<<< + * self.rinfo.get_array(self.params.rinfo) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfo); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_v_self->rinfo = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":388 + * # real/complex information parameters + * self.rinfo = cmumps_real_array() + * self.rinfo.get_array(self.params.rinfo) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_v_self->rinfo->__pyx_vtab)->get_array(__pyx_v_self->rinfo, __pyx_v_self->params.rinfo, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":391 + * + * # real/complex information parameters + * self.rinfog = cmumps_real_array() # <<<<<<<<<<<<<< + * self.rinfog.get_array(self.params.rinfog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_v_self->rinfog = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":392 + * # real/complex information parameters + * self.rinfog = cmumps_real_array() + * self.rinfog.get_array(self.params.rinfog) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)__pyx_v_self->rinfog->__pyx_vtab)->get_array(__pyx_v_self->rinfog, __pyx_v_self->params.rinfog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.initialize_mumps_struct", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_get_data_pointers(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, CMUMPS_COMPLEX *__pyx_v_a_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_data_pointers", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":410 + * """ + * + * self.a_row = a_row # <<<<<<<<<<<<<< + * self.a_col = a_col + * self.a_val = a_val + */ + __pyx_v_self->a_row = ((MUMPS_INT *)__pyx_v_a_row); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":411 + * + * self.a_row = a_row + * self.a_col = a_col # <<<<<<<<<<<<<< + * self.a_val = a_val + * + */ + __pyx_v_self->a_col = ((MUMPS_INT *)__pyx_v_a_col); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":412 + * self.a_row = a_row + * self.a_col = a_col + * self.a_val = a_val # <<<<<<<<<<<<<< + * + * # transform c index arrays to fortran arrays + */ + __pyx_v_self->a_val = ((CMUMPS_COMPLEX *)__pyx_v_a_val); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":415 + * + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) # <<<<<<<<<<<<<< + * c_to_fortran_index_array(self.a_col, self.nnz) + * + */ + __pyx_t_1 = __pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_c_to_fortran_index_array(__pyx_v_self->a_row, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":416 + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) + * c_to_fortran_index_array(self.a_col, self.nnz) # <<<<<<<<<<<<<< + * + * self.set_centralized_assembled_matrix() + */ + __pyx_t_1 = __pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_c_to_fortran_index_array(__pyx_v_self->a_col, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":418 + * c_to_fortran_index_array(self.a_col, self.nnz) + * + * self.set_centralized_assembled_matrix() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->set_centralized_assembled_matrix(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.get_data_pointers", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_centralized_assembled_matrix", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":427 + * """ + * + * self.params.nz = self.nnz # <<<<<<<<<<<<<< + * + * self.params.irn = self.a_row + */ + __pyx_v_self->params.nz = ((MUMPS_INT)__pyx_v_self->nnz); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":429 + * self.params.nz = self.nnz + * + * self.params.irn = self.a_row # <<<<<<<<<<<<<< + * self.params.jcn = self.a_col + * self.params.a = self.a_val + */ + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_self->a_row); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":430 + * + * self.params.irn = self.a_row + * self.params.jcn = self.a_col # <<<<<<<<<<<<<< + * self.params.a = self.a_val + * + */ + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_self->a_col); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":431 + * self.params.irn = self.a_row + * self.params.jcn = self.a_col + * self.params.a = self.a_val # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_self->params.a = ((CMUMPS_COMPLEX *)__pyx_v_self->a_val); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + +/* Python wrapper */ +static void __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2__dealloc__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2__dealloc__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":436 + * def __dealloc__(self): + * # autodestruct mumps internal + * self.params.job = -2 # <<<<<<<<<<<<<< + * self.mumps_call() + * self.params.job = -1 + */ + __pyx_v_self->params.job = -2; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":437 + * # autodestruct mumps internal + * self.params.job = -2 + * self.mumps_call() # <<<<<<<<<<<<<< + * self.params.job = -1 + * self.mumps_call() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":438 + * self.params.job = -2 + * self.mumps_call() + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":439 + * self.mumps_call() + * self.params.job = -1 + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # Properties + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_WriteUnraisable("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":444 + * # COMMON Properties + * property analyzed: + * def __get__(self): return self.analyzed # <<<<<<<<<<<<<< + * property factorized: + * def __get__(self): return self.factorized + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8analyzed_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8analyzed_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8analyzed___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8analyzed___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->analyzed); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.analyzed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":446 + * def __get__(self): return self.analyzed + * property factorized: + * def __get__(self): return self.factorized # <<<<<<<<<<<<<< + * property sym: + * def __get__(self): return self.params.sym + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10factorized_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10factorized_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10factorized___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10factorized___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->factorized); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.factorized.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":448 + * def __get__(self): return self.factorized + * property sym: + * def __get__(self): return self.params.sym # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.sym = value + * property par: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.sym.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":449 + * property sym: + * def __get__(self): return self.params.sym + * def __set__(self, value): self.params.sym = value # <<<<<<<<<<<<<< + * property par: + * def __get__(self): return self.params.par + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.sym.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":451 + * def __set__(self, value): self.params.sym = value + * property par: + * def __get__(self): return self.params.par # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.par = value + * property job: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.par); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.par.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":452 + * property par: + * def __get__(self): return self.params.par + * def __set__(self, value): self.params.par = value # <<<<<<<<<<<<<< + * property job: + * def __get__(self): return self.params.job + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 452; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.par = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.par.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":454 + * def __set__(self, value): self.params.par = value + * property job: + * def __get__(self): return self.params.job # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.job = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.job); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.job.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":455 + * property job: + * def __get__(self): return self.params.job + * def __set__(self, value): self.params.job = value # <<<<<<<<<<<<<< + * + * property comm_fortran: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.job = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.job.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":458 + * + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.comm_fortran = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.comm_fortran); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 458; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.comm_fortran.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":459 + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran + * def __set__(self, value): self.params.comm_fortran = value # <<<<<<<<<<<<<< + * + * property icntl: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 459; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.comm_fortran.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5icntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5icntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5icntl___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5icntl___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":463 + * property icntl: + * def __get__(self): + * return self.icntl # <<<<<<<<<<<<<< + * + * property n: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_r = ((PyObject *)__pyx_v_self->icntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":466 + * + * property n: + * def __get__(self): return self.params.n # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.n = value + * property nz_alloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.n); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.n.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":467 + * property n: + * def __get__(self): return self.params.n + * def __set__(self, value): self.params.n = value # <<<<<<<<<<<<<< + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.n = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.n.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":469 + * def __set__(self, value): self.params.n = value + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_alloc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_alloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 469; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz_alloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":470 + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + * def __set__(self, value): self.params.nz_alloc = value # <<<<<<<<<<<<<< + * + * property nz: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 470; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_alloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz_alloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":473 + * + * property nz: + * def __get__(self): return self.params.nz # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz = value + * property irn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 473; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":474 + * property nz: + * def __get__(self): return self.params.nz + * def __set__(self, value): self.params.nz = value # <<<<<<<<<<<<<< + * property irn: + * def __get__(self): return self.params.irn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":476 + * def __set__(self, value): self.params.nz = value + * property irn: + * def __get__(self): return self.params.irn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn = value + * property jcn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":477 + * property irn: + * def __get__(self): return self.params.irn + * def __set__(self, long value): self.params.irn = value # <<<<<<<<<<<<<< + * property jcn: + * def __get__(self): return self.params.jcn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":479 + * def __set__(self, long value): self.params.irn = value + * property jcn: + * def __get__(self): return self.params.jcn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.jcn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":480 + * property jcn: + * def __get__(self): return self.params.jcn + * def __set__(self, long value): self.params.jcn = value # <<<<<<<<<<<<<< + * + * property nz_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.jcn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":483 + * + * property nz_loc: + * def __get__(self): return self.params.nz_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":484 + * property nz_loc: + * def __get__(self): return self.params.nz_loc + * def __set__(self, value): self.params.nz_loc = value # <<<<<<<<<<<<<< + * property irn_loc: + * def __get__(self): return self.params.irn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":486 + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + * def __get__(self): return self.params.irn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":487 + * property irn_loc: + * def __get__(self): return self.params.irn_loc + * def __set__(self, long value): self.params.irn_loc = value # <<<<<<<<<<<<<< + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":489 + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.jcn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":490 + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + * def __set__(self, long value): self.params.jcn_loc = value # <<<<<<<<<<<<<< + * + * property nelt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 490; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.jcn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":493 + * + * property nelt: + * def __get__(self): return self.params.nelt # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nelt = value + * property eltptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nelt); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 493; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nelt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":494 + * property nelt: + * def __get__(self): return self.params.nelt + * def __set__(self, value): self.params.nelt = value # <<<<<<<<<<<<<< + * property eltptr: + * def __get__(self): return self.params.eltptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 494; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nelt = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nelt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":496 + * def __set__(self, value): self.params.nelt = value + * property eltptr: + * def __get__(self): return self.params.eltptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 496; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.eltptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":497 + * property eltptr: + * def __get__(self): return self.params.eltptr + * def __set__(self, long value): self.params.eltptr = value # <<<<<<<<<<<<<< + * property eltvar: + * def __get__(self): return self.params.eltvar + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 497; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.eltptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":499 + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + * def __get__(self): return self.params.eltvar # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltvar = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltvar)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.eltvar.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":500 + * property eltvar: + * def __get__(self): return self.params.eltvar + * def __set__(self, long value): self.params.eltvar = value # <<<<<<<<<<<<<< + * + * property perm_in: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.eltvar.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltvar = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":503 + * + * property perm_in: + * def __get__(self): return self.params.perm_in # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.perm_in = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.perm_in)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 503; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.perm_in.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":504 + * property perm_in: + * def __get__(self): return self.params.perm_in + * def __set__(self, long value): self.params.perm_in = value # <<<<<<<<<<<<<< + * + * property sym_perm: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.perm_in.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.perm_in = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":507 + * + * property sym_perm: + * def __get__(self): return self.params.sym_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sym_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.sym_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":508 + * property sym_perm: + * def __get__(self): return self.params.sym_perm + * def __set__(self, long value): self.params.sym_perm = value # <<<<<<<<<<<<<< + * property uns_perm: + * def __get__(self): return self.params.uns_perm + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 508; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.sym_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sym_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":510 + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + * def __get__(self): return self.params.uns_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.uns_perm = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.uns_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.uns_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":511 + * property uns_perm: + * def __get__(self): return self.params.uns_perm + * def __set__(self, long value): self.params.uns_perm = value # <<<<<<<<<<<<<< + * + * property irhs_sparse: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.uns_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.uns_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":514 + * + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 514; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":515 + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse + * def __set__(self, long value): self.params.irhs_sparse = value # <<<<<<<<<<<<<< + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 515; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":517 + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_ptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 517; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irhs_ptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":518 + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + * def __set__(self, long value): self.params.irhs_ptr = value # <<<<<<<<<<<<<< + * property isol_loc: + * def __get__(self): return self.params.isol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.irhs_ptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":520 + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + * def __get__(self): return self.params.isol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.isol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.isol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 520; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.isol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":521 + * property isol_loc: + * def __get__(self): return self.params.isol_loc + * def __set__(self, long value): self.params.isol_loc = value # <<<<<<<<<<<<<< + * + * property nrhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 521; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.isol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.isol_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":524 + * + * property nrhs: + * def __get__(self): return self.params.nrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":525 + * property nrhs: + * def __get__(self): return self.params.nrhs + * def __set__(self, value): self.params.nrhs = value # <<<<<<<<<<<<<< + * property lrhs: + * def __get__(self): return self.params.lrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":527 + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + * def __get__(self): return self.params.lrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":528 + * property lrhs: + * def __get__(self): return self.params.lrhs + * def __set__(self, value): self.params.lrhs = value # <<<<<<<<<<<<<< + * property lredrhs: + * def __get__(self): return self.params.lredrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":530 + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + * def __get__(self): return self.params.lredrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lredrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 530; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lredrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":531 + * property lredrhs: + * def __get__(self): return self.params.lredrhs + * def __set__(self, value): self.params.lredrhs = value # <<<<<<<<<<<<<< + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 531; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lredrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lredrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":533 + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_rhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 533; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz_rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":534 + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + * def __set__(self, value): self.params.nz_rhs = value # <<<<<<<<<<<<<< + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 534; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_rhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nz_rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":536 + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lsol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lsol_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lsol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":537 + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + * def __set__(self, value): self.params.lsol_loc = value # <<<<<<<<<<<<<< + * + * property schur_mloc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lsol_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lsol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":540 + * + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_mloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur_mloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":541 + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc + * def __set__(self, value): self.params.schur_mloc = value # <<<<<<<<<<<<<< + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 541; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_mloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur_mloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":543 + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_nloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 543; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur_nloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":544 + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + * def __set__(self, value): self.params.schur_nloc = value # <<<<<<<<<<<<<< + * property schur_lld: + * def __get__(self): return self.params.schur_lld + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_nloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur_nloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":546 + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + * def __get__(self): return self.params.schur_lld # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_lld = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_lld); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 546; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur_lld.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":547 + * property schur_lld: + * def __get__(self): return self.params.schur_lld + * def __set__(self, value): self.params.schur_lld = value # <<<<<<<<<<<<<< + * + * property mblock: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_lld = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur_lld.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":550 + * + * property mblock: + * def __get__(self): return self.params.mblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.mblock = value + * property nblock: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.mblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 550; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.mblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":551 + * property mblock: + * def __get__(self): return self.params.mblock + * def __set__(self, value): self.params.mblock = value # <<<<<<<<<<<<<< + * property nblock: + * def __get__(self): return self.params.nblock + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 551; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.mblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.mblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":553 + * def __set__(self, value): self.params.mblock = value + * property nblock: + * def __get__(self): return self.params.nblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nblock = value + * property nprow: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":554 + * property nblock: + * def __get__(self): return self.params.nblock + * def __set__(self, value): self.params.nblock = value # <<<<<<<<<<<<<< + * property nprow: + * def __get__(self): return self.params.nprow + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 554; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":556 + * def __set__(self, value): self.params.nblock = value + * property nprow: + * def __get__(self): return self.params.nprow # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nprow = value + * property npcol: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nprow); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nprow.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":557 + * property nprow: + * def __get__(self): return self.params.nprow + * def __set__(self, value): self.params.nprow = value # <<<<<<<<<<<<<< + * property npcol: + * def __get__(self): return self.params.npcol + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nprow = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.nprow.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":559 + * def __set__(self, value): self.params.nprow = value + * property npcol: + * def __get__(self): return self.params.npcol # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.npcol = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.npcol); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.npcol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":560 + * property npcol: + * def __get__(self): return self.params.npcol + * def __set__(self, value): self.params.npcol = value # <<<<<<<<<<<<<< + * + * property info: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.npcol = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.npcol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4info_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4info_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4info___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4info___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":564 + * property info: + * def __get__(self): + * return self.info # <<<<<<<<<<<<<< + * + * property infog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->info)); + __pyx_r = ((PyObject *)__pyx_v_self->info); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5infog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5infog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5infog___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5infog___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":568 + * property infog: + * def __get__(self): + * return self.infog # <<<<<<<<<<<<<< + * + * property deficiency: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __pyx_r = ((PyObject *)__pyx_v_self->infog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":571 + * + * property deficiency: + * def __get__(self): return self.params.deficiency # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.deficiency); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.deficiency.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":572 + * property deficiency: + * def __get__(self): return self.params.deficiency + * def __set__(self, value): self.params.deficiency = value # <<<<<<<<<<<<<< + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.deficiency = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.deficiency.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":574 + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.pivnul_list)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 574; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.pivnul_list.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":575 + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + * def __set__(self, long value): self.params.pivnul_list = value # <<<<<<<<<<<<<< + * property mapping: + * def __get__(self): return self.params.mapping + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 575; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.pivnul_list.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.pivnul_list = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":577 + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + * def __get__(self): return self.params.mapping # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.mapping = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.mapping)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.mapping.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":578 + * property mapping: + * def __get__(self): return self.params.mapping + * def __set__(self, long value): self.params.mapping = value # <<<<<<<<<<<<<< + * + * property size_schur: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 578; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.mapping.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.mapping = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":581 + * + * property size_schur: + * def __get__(self): return self.params.size_schur # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.size_schur); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 581; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.size_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":582 + * property size_schur: + * def __get__(self): return self.params.size_schur + * def __set__(self, value): self.params.size_schur = value # <<<<<<<<<<<<<< + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 582; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.size_schur = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.size_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":584 + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.listvar_schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.listvar_schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 584; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.listvar_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":585 + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + * def __set__(self, long value): self.params.listvar_schur = value # <<<<<<<<<<<<<< + * + * property instance_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.listvar_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.listvar_schur = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":588 + * + * property instance_number: + * def __get__(self): return self.params.instance_number # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.instance_number = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.instance_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.instance_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":589 + * property instance_number: + * def __get__(self): return self.params.instance_number + * def __set__(self, value): self.params.instance_number = value # <<<<<<<<<<<<<< + * + * property version_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 589; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.instance_number = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.instance_number.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_14version_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_14version_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_14version_number___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_14version_number___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":593 + * property version_number: + * def __get__(self): + * return ( self.params.version_number).decode('ascii') # <<<<<<<<<<<<<< + * + * property ooc_tmpdir: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.version_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.version_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":597 + * property ooc_tmpdir: + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_tmpdir); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.ooc_tmpdir.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 598; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.ooc_tmpdir.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":599 + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) # <<<<<<<<<<<<<< + * property ooc_prefix: + * def __get__(self): + */ + strncpy(__pyx_v_self->params.ooc_tmpdir, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_tmpdir))); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":602 + * property ooc_prefix: + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_prefix); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.ooc_prefix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 603; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.ooc_prefix.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":604 + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) # <<<<<<<<<<<<<< + * + * property write_problem: + */ + strncpy(__pyx_v_self->params.ooc_prefix, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_prefix))); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":608 + * property write_problem: + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.write_problem); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.write_problem.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.write_problem.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":610 + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) # <<<<<<<<<<<<<< + * + * property lwk_user: + */ + strncpy(__pyx_v_self->params.write_problem, __pyx_v_value, (sizeof(__pyx_v_self->params.write_problem))); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":613 + * + * property lwk_user: + * def __get__(self): return self.params.lwk_user # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lwk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lwk_user); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lwk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":614 + * property lwk_user: + * def __get__(self): return self.params.lwk_user + * def __set__(self, value): self.params.lwk_user = value # <<<<<<<<<<<<<< + * + * # TYPED Properties + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lwk_user = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.lwk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4cntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4cntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4cntl___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4cntl___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":619 + * property cntl: + * def __get__(self): + * return self.cntl # <<<<<<<<<<<<<< + * + * property a: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_r = ((PyObject *)__pyx_v_self->cntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":622 + * + * property a: + * def __get__(self): return self.params.a # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.a.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":623 + * property a: + * def __get__(self): return self.params.a + * def __set__(self, long value): self.params.a = value # <<<<<<<<<<<<<< + * + * property a_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.a.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":626 + * + * property a_loc: + * def __get__(self): return self.params.a_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 626; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.a_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":627 + * property a_loc: + * def __get__(self): return self.params.a_loc + * def __set__(self, long value): self.params.a_loc = value # <<<<<<<<<<<<<< + * + * property a_elt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 627; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.a_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_loc = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":630 + * + * property a_elt: + * def __get__(self): return self.params.a_elt # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_elt = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_elt)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 630; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.a_elt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":631 + * property a_elt: + * def __get__(self): return self.params.a_elt + * def __set__(self, long value): self.params.a_elt = value # <<<<<<<<<<<<<< + * + * property colsca: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.a_elt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_elt = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":634 + * + * property colsca: + * def __get__(self): return self.params.colsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.colsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.colsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":635 + * property colsca: + * def __get__(self): return self.params.colsca + * def __set__(self, long value): self.params.colsca = value # <<<<<<<<<<<<<< + * property rowsca: + * def __get__(self): return self.params.rowsca + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.colsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.colsca = ((CMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":637 + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + * def __get__(self): return self.params.rowsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rowsca = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rowsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.rowsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":638 + * property rowsca: + * def __get__(self): return self.params.rowsca + * def __set__(self, long value): self.params.rowsca = value # <<<<<<<<<<<<<< + * + * property rhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.rowsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rowsca = ((CMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":641 + * + * property rhs: + * def __get__(self): return self.params.rhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 641; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":642 + * property rhs: + * def __get__(self): return self.params.rhs + * def __set__(self, long value): self.params.rhs = value # <<<<<<<<<<<<<< + * property redrhs: + * def __get__(self): return self.params.redrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":644 + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + * def __get__(self): return self.params.redrhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.redrhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.redrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":645 + * property redrhs: + * def __get__(self): return self.params.redrhs + * def __set__(self, long value): self.params.redrhs = value # <<<<<<<<<<<<<< + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 645; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.redrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.redrhs = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":647 + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.rhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":648 + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + * def __set__(self, long value): self.params.rhs_sparse = value # <<<<<<<<<<<<<< + * property sol_loc: + * def __get__(self): return self.params.sol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.rhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs_sparse = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":650 + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + * def __get__(self): return self.params.sol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.sol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":651 + * property sol_loc: + * def __get__(self): return self.params.sol_loc + * def __set__(self, long value): self.params.sol_loc = value # <<<<<<<<<<<<<< + * + * property rinfo: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.sol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sol_loc = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5rinfo_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5rinfo_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5rinfo___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5rinfo___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":655 + * property rinfo: + * def __get__(self): + * return self.rinfo # <<<<<<<<<<<<<< + * + * property rinfog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfo); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rinfog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rinfog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rinfog___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rinfog___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":659 + * property rinfog: + * def __get__(self): + * return self.rinfog # <<<<<<<<<<<<<< + * + * property schur: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":662 + * + * property schur: + * def __get__(self): return self.params.schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":663 + * property schur: + * def __get__(self): return self.params.schur + * def __set__(self, long value): self.params.schur = value # <<<<<<<<<<<<<< + * + * property wk_user: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.schur = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":666 + * + * property wk_user: + * def __get__(self): return self.params.wk_user # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.wk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user___get__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user___get__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.wk_user)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.wk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":667 + * property wk_user: + * def __get__(self): return self.params.wk_user + * def __set__(self, long value): self.params.wk_user = value # <<<<<<<<<<<<<< + * + * # MUMPS CALL + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 667; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.wk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_2__set__(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.wk_user = ((CMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mumps_call(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mumps_call", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":674 + * Call to Xmumps_c(XMUMPS_STRUC_C). + * """ + * cmumps_c(&self.params) # <<<<<<<<<<<<<< + * + * + */ + cmumps_c((&__pyx_v_self->params)); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4set_silent[] = "\n Silence **all* MUMPS output.\n\n See MUMPS documentation.\n "; +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_silent (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4set_silent(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4set_silent(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_silent", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":683 + * See MUMPS documentation. + * """ + * self.icntl[1] = 0 # <<<<<<<<<<<<<< + * self.icntl[2] = 0 + * self.icntl[3] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 1, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":684 + * """ + * self.icntl[1] = 0 + * self.icntl[2] = 0 # <<<<<<<<<<<<<< + * self.icntl[3] = 0 + * self.icntl[4] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":685 + * self.icntl[1] = 0 + * self.icntl[2] = 0 + * self.icntl[3] = 0 # <<<<<<<<<<<<<< + * self.icntl[4] = 0 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 3, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":686 + * self.icntl[2] = 0 + * self.icntl[3] = 0 + * self.icntl[4] = 0 # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 4, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.set_silent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6analyze[] = "\n Performs analysis step of MUMPS.\n\n In the analyis step, MUMPS is able to figure out a reordering for the \n given matrix. It does so if `ordering` is set to 'auto'.\n If not MUMPS will use the provided ordering.\n MUMPS statistics for the analysis are available in `analysis_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n "; +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("analyze (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "analyze") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("analyze", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6analyze(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), __pyx_v_ordering); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6analyze(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_ordering) { + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("analyze", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_1 = (__pyx_v_self->analyzed != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":705 + * """ + * if self.analyzed: + * return # <<<<<<<<<<<<<< + * + * self.icntl[7] = orderings[ordering] + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":707 + * return + * + * self.icntl[7] = orderings[ordering] # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.params.job = 1 # analyse + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_orderings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_ordering); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 7, __pyx_t_3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":708 + * + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.params.job = 1 # analyse + * self.mumps_call() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_t1 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":709 + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() + * self.params.job = 1 # analyse # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_v_self->params.job = 1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":710 + * t1 = time.clock() + * self.params.job = 1 # analyse + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":711 + * self.params.job = 1 # analyse + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * if self.infog[1] < 0: + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_t2 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":714 + * + * if self.infog[1] < 0: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * + * self.analyzed = True + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":716 + * raise MUMPSError(self.infog) + * + * self.analyzed = True # <<<<<<<<<<<<<< + * + * # self.analysis_stats = AnalysisStatistics(self.params, + */ + __pyx_v_self->analyzed = 1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8factorize[] = "\n Perform the LU factorization of the matrix (or LDL' if the matrix\n is symmetric).\n\n This factorization can then later be used to solve a linear system\n with `solve`. Statistical data of the factorization is stored in\n `factor_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n pivot_tol: number in the range [0, 1]\n pivoting threshold. Pivoting is typically limited in sparse\n solvers, as too much pivoting destroys sparsity. 1.0 means full\n pivoting, whereas 0.0 means no pivoting. Default is 0.01.\n "; +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + PyObject *__pyx_v_pivot_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("factorize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,&__pyx_n_s_pivot_tol,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + values[1] = ((PyObject *)__pyx_float_0_01); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pivot_tol); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "factorize") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + __pyx_v_pivot_tol = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("factorize", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8factorize(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), __pyx_v_ordering, __pyx_v_pivot_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8factorize(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol) { + int __pyx_v_done; + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("factorize", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + __pyx_t_1 = ((!(__pyx_v_self->analyzed != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":744 + * # Analysis phase must be done before factorization + * if not self.analyzed : + * self.analyze(ordering=ordering) # <<<<<<<<<<<<<< + * + * self.icntl[22] = 1 if self.out_of_core else 1 + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_analyze); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_ordering, __pyx_v_ordering) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":746 + * self.analyze(ordering=ordering) + * + * self.icntl[22] = 1 if self.out_of_core else 1 # <<<<<<<<<<<<<< + * self.cntl[1] = pivot_tol + * self.params.job = 2 + */ + if ((__pyx_v_self->out_of_core != 0)) { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 22, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":747 + * + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol # <<<<<<<<<<<<<< + * self.params.job = 2 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 1, __pyx_v_pivot_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":748 + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol + * self.params.job = 2 # <<<<<<<<<<<<<< + * + * done = False + */ + __pyx_v_self->params.job = 2; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":750 + * self.params.job = 2 + * + * done = False # <<<<<<<<<<<<<< + * while not done: + * t1 = time.clock() + */ + __pyx_v_done = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":751 + * + * done = False + * while not done: # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.mumps_call() + */ + while (1) { + __pyx_t_1 = ((!(__pyx_v_done != 0)) != 0); + if (!__pyx_t_1) break; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":752 + * done = False + * while not done: + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_t1, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":753 + * while not done: + * t1 = time.clock() + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":754 + * t1 = time.clock() + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * # error -8, -9 (not enough allocated memory) is treated + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_t2, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + __pyx_t_4 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_8, -8L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_5) { + } else { + __pyx_t_1 = __pyx_t_5; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_9, -9L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_L8_bool_binop_done:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":761 + * if self.infog[1] in (-8, -9): + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 # <<<<<<<<<<<<<< + * else: + * raise MUMPSError(self.infog) + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->icntl), 14, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_int_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 14, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":763 + * self.icntl[14] = self.icntl[14]*2 + * else: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * else: + * done = True + */ + /*else*/ { + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":765 + * raise MUMPSError(self.infog) + * else: + * done = True # <<<<<<<<<<<<<< + * + * self.factorized = True + */ + /*else*/ { + __pyx_v_done = 1; + } + __pyx_L6:; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":767 + * done = True + * + * self.factorized = True # <<<<<<<<<<<<<< + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + */ + __pyx_v_self->factorized = 1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, CMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_solve_dense(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, CMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_dense", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":782 + * MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + * """ + * self.params.nrhs = nrhs # <<<<<<<<<<<<<< + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + */ + __pyx_v_self->params.nrhs = ((MUMPS_INT)__pyx_v_nrhs); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":783 + * """ + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length # <<<<<<<<<<<<<< + * self.params.rhs = rhs + * self.params.job = 3 # solve + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_rhs_length); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":784 + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length + * self.params.rhs = rhs # <<<<<<<<<<<<<< + * self.params.job = 3 # solve + * self.mumps_call() + */ + __pyx_v_self->params.rhs = ((CMUMPS_COMPLEX *)__pyx_v_rhs); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":785 + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":786 + * self.params.rhs = rhs + * self.params.job = 3 # solve + * self.mumps_call() # <<<<<<<<<<<<<< + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, CMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.solve_dense", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * CMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * CMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + +static PyObject *__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_solve_sparse(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, CMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, CMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_sparse", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":807 + * + * """ + * self.params.nz_rhs = rhs_nnz # <<<<<<<<<<<<<< + * self.params.nrhs = nrhs # nrhs -1 ? + * + */ + __pyx_v_self->params.nz_rhs = __pyx_v_rhs_nnz; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":808 + * """ + * self.params.nz_rhs = rhs_nnz + * self.params.nrhs = nrhs # nrhs -1 ? # <<<<<<<<<<<<<< + * + * self.params.rhs_sparse = rhs_val + */ + __pyx_v_self->params.nrhs = __pyx_v_nrhs; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":810 + * self.params.nrhs = nrhs # nrhs -1 ? + * + * self.params.rhs_sparse = rhs_val # <<<<<<<<<<<<<< + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr + */ + __pyx_v_self->params.rhs_sparse = ((CMUMPS_COMPLEX *)__pyx_v_rhs_val); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":811 + * + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind # <<<<<<<<<<<<<< + * self.params.irhs_ptr = rhs_col_ptr + * + */ + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_rhs_row_ind); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":812 + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr # <<<<<<<<<<<<<< + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + */ + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_rhs_col_ptr); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":815 + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length # <<<<<<<<<<<<<< + * self.params.rhs = x + * + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_x_length); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":816 + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length + * self.params.rhs = x # <<<<<<<<<<<<<< + * + * self.params.job = 3 # solve + */ + __pyx_v_self->params.rhs = ((CMUMPS_COMPLEX *)__pyx_v_x); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":818 + * self.params.rhs = x + * + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":819 + * + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 20, __pyx_int_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":820 + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() # <<<<<<<<<<<<<< + * + * def solve(self, **kwargs): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * CMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * CMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.solve_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10solve[] = "\n\n Args:\n rhs: dense NumPy array (matrix or vector).\n rhs_col_ptr, rhs_row_ind, rhs_val: sparse NumPy CSC arrays (matrix or vector).\n transpose_solve : ``True`` or ``False`` whether to solve A * x = rhs or A^T * x = rhs. Default is ``False``\n\n Returns:\n Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system.\n "; +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_kwargs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solve (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;} + if (__pyx_kwds && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 1))) return NULL; + __pyx_v_kwargs = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10solve(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), __pyx_v_kwargs); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5solve_genexpr(PyObject *__pyx_self) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *)__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5solve_2generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_solve_locals_genexpr); if (unlikely(!gen)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.solve.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __pyx_tuple__3; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= 3) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_arg); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_arg, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs)) { __Pyx_RaiseClosureNameError("kwargs"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } + if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_cur_scope->__pyx_v_arg, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (__pyx_t_5) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + } + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10solve(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_kwargs) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *__pyx_cur_scope; + PyObject *__pyx_v_transpose_solve = NULL; + MUMPS_INT __pyx_v_nrhs; + PyObject *__pyx_v_rhs = NULL; + PyObject *__pyx_v_rhs_shape = NULL; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_v_rhs_col_ptr = NULL; + PyObject *__pyx_v_rhs_row_ind = NULL; + PyObject *__pyx_v_rhs_val = NULL; + MUMPS_INT __pyx_v_x_length; + PyObject *__pyx_v_rhs_nnz = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + MUMPS_INT __pyx_t_8; + MUMPS_INT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *)__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_v_kwargs = __pyx_v_kwargs; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_kwargs); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_kwargs); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + __pyx_t_1 = ((!(__pyx_v_self->factorized != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":834 + * """ + * if not self.factorized: + * self.factorize() # <<<<<<<<<<<<<< + * + * transpose_solve = kwargs.get('transpose_solve', False) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_factorize); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":836 + * self.factorize() + * + * transpose_solve = kwargs.get('transpose_solve', False) # <<<<<<<<<<<<<< + * self.icntl[9] = 2 if transpose_solve else 1 + * + */ + __pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_transpose_solve, Py_False); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_transpose_solve = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":837 + * + * transpose_solve = kwargs.get('transpose_solve', False) + * self.icntl[9] = 2 if transpose_solve else 1 # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_transpose_solve); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__pyx_t_1) { + __Pyx_INCREF(__pyx_int_2); + __pyx_t_2 = __pyx_int_2; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_2 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 9, __pyx_t_2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_rhs, __pyx_cur_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":844 + * # rhs can be dense or sparse + * if 'rhs' in kwargs: + * rhs = kwargs['rhs'] # <<<<<<<<<<<<<< + * + * if not cnp.PyArray_Check(rhs): + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_5 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":850 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":855 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # create x + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":853 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":858 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (__pyx_t_7) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":862 + * # test number of columns in rhs + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * nrhs = rhs_shape[1] + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":864 + * nrhs = 1 + * else: + * nrhs = rhs_shape[1] # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = ((MUMPS_INT)__pyx_t_8); + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":866 + * nrhs = rhs_shape[1] + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((CMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_9, __pyx_v_nrhs); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_t_4 = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5solve_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_Generator_Next(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":870 + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] # <<<<<<<<<<<<<< + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_col_ptr); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_col_ptr = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":871 + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] # <<<<<<<<<<<<<< + * rhs_val = kwargs['rhs_val'] + * + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_row_ind); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_row_ind = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":872 + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] # <<<<<<<<<<<<<< + * + * # fortran indices, done internally in C: no efficiency lost + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_val); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 872; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_val = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":875 + * + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 # <<<<<<<<<<<<<< + * rhs_row_ind += 1 + * + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_col_ptr, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_col_ptr, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":876 + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 + * rhs_row_ind += 1 # <<<<<<<<<<<<<< + * + * nrhs = rhs_col_ptr.size - 1 + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_row_ind, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_row_ind, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":878 + * rhs_row_ind += 1 + * + * nrhs = rhs_col_ptr.size - 1 # <<<<<<<<<<<<<< + * x_length = self.nrow + * rhs_nnz = rhs_val.size + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_col_ptr, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = __pyx_t_8; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":879 + * + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow # <<<<<<<<<<<<<< + * rhs_nnz = rhs_val.size + * + */ + __pyx_t_9 = __pyx_v_self->nrow; + __pyx_v_x_length = __pyx_t_9; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":880 + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow + * rhs_nnz = rhs_val.size # <<<<<<<<<<<<<< + * + * x = np.zeros([self.nrow, nrhs], dtype=np.complex64) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_val, __pyx_n_s_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 880; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_rhs_nnz = __pyx_t_4; + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":882 + * rhs_nnz = rhs_val.size + * + * x = np.zeros([self.nrow, nrhs], dtype=np.complex64) # <<<<<<<<<<<<<< + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_nrhs); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_complex64); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_x = __pyx_t_6; + __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.complex64) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + if (!(likely(((__pyx_v_rhs_col_ptr) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_col_ptr, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_rhs_row_ind) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_row_ind, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":885 + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), # <<<<<<<<<<<<<< + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + */ + if (!(likely(((__pyx_v_rhs_val) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_val, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 885; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":886 + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) # <<<<<<<<<<<<<< + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + */ + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_rhs_nnz); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.complex64) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->solve_sparse(__pyx_v_self, ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_col_ptr))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_row_ind))), ((CMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_val))), __pyx_t_9, __pyx_v_nrhs, ((CMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_v_x_length); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L4:; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":890 + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + * + * return x # <<<<<<<<<<<<<< + * + * def refine(self, rhs, nitref = 3, tol=None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.solve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_transpose_solve); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XDECREF(__pyx_v_rhs_col_ptr); + __Pyx_XDECREF(__pyx_v_rhs_row_ind); + __Pyx_XDECREF(__pyx_v_rhs_val); + __Pyx_XDECREF(__pyx_v_rhs_nnz); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_COMPLEX64.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12refine[] = "\n refine(rhs, nitref) performs iterative refinement if necessary\n until the scaled residual norm ||b-Ax||/(1+||b||) falls below the\n threshold 'tol' or until nitref steps are taken.\n Parameters:\n nitref : < 0 : Fixed number of steps of iterative refinement. No stopping criterion is used. \n 0 : No iterative refinement.\n > 0 : Maximum number of steps of iterative refinement. A stopping criterion is used,\n therefore a test for convergence is done at each step of the iterative refinement algorithm.\n Default: 3\n tol : is the stopping criterion for iterative refinement\n\n Make sure you have called `solve()` with the same right-hand\n side rhs before calling `refine()`.\n The residual vector self.residual will be updated to reflect\n the updated approximate solution.\n "; +static PyObject *__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_rhs = 0; + PyObject *__pyx_v_nitref = 0; + PyObject *__pyx_v_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("refine (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rhs,&__pyx_n_s_nitref,&__pyx_n_s_tol,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)__pyx_int_3); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nitref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tol); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "refine") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_rhs = values[0]; + __pyx_v_nitref = values[1]; + __pyx_v_tol = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("refine", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12refine(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), __pyx_v_rhs, __pyx_v_nitref, __pyx_v_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12refine(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol) { + PyObject *__pyx_v_rhs_shape = NULL; + long __pyx_v_nrhs; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + MUMPS_INT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("refine", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_1 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":917 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":922 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs. + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":920 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":927 + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L5; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":929 + * nrhs = 1 + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ # <<<<<<<<<<<<<< + * "refinement.") + * + */ + /*else*/ { + __pyx_t_2 = PyNumber_Add(__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_kp_s_refinement); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L5:; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":933 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * self.icntl[10] = nitref + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":935 + * x = np.asfortranarray(rhs.copy()) + * + * self.icntl[10] = nitref # <<<<<<<<<<<<<< + * if tol is None: + * self.cntl[2] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_v_nitref, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + __pyx_t_1 = (__pyx_v_tol == Py_None); + __pyx_t_7 = (__pyx_t_1 != 0); + if (__pyx_t_7) { + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":937 + * self.icntl[10] = nitref + * if tol is None: + * self.cntl[2] = 0 # <<<<<<<<<<<<<< + * else: + * self.cntl[2] = tol + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":939 + * self.cntl[2] = 0 + * else: + * self.cntl[2] = tol # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_v_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L6:; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":941 + * self.cntl[2] = tol + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * # reset to default values + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_2); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((CMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_8, __pyx_v_nrhs); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":944 + * + * # reset to default values + * self.icntl[10] = 0 # <<<<<<<<<<<<<< + * self.cntl[2] = -1 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":945 + * # reset to default values + * self.icntl[10] = 0 + * self.cntl[2] = -1 # <<<<<<<<<<<<<< + * + * return x + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_neg_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":947 + * self.cntl[2] = -1 + * + * return x # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; + +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; + if (unlikely(__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_mumps_int_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_mumps_int_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX64.mumps_int_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_mumps_int_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_mumps_int_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Integer version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; + +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; + if (unlikely(__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_cmumps_real_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_cmumps_real_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX64.cmumps_real_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_cmumps_real_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_cmumps_real_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Real version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + p->icntl = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->info = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->infog = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->cntl = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfo = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfog = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + p->solve_stats = Py_None; Py_INCREF(Py_None); + if (unlikely(__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64(PyObject *o) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->icntl); + Py_CLEAR(p->info); + Py_CLEAR(p->infog); + Py_CLEAR(p->cntl); + Py_CLEAR(p->rinfo); + Py_CLEAR(p->rinfog); + Py_CLEAR(p->analysis_stats); + Py_CLEAR(p->factorize_stats); + Py_CLEAR(p->solve_stats); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)o; + if (p->icntl) { + e = (*v)(((PyObject*)p->icntl), a); if (e) return e; + } + if (p->info) { + e = (*v)(((PyObject*)p->info), a); if (e) return e; + } + if (p->infog) { + e = (*v)(((PyObject*)p->infog), a); if (e) return e; + } + if (p->cntl) { + e = (*v)(((PyObject*)p->cntl), a); if (e) return e; + } + if (p->rinfo) { + e = (*v)(((PyObject*)p->rinfo), a); if (e) return e; + } + if (p->rinfog) { + e = (*v)(((PyObject*)p->rinfog), a); if (e) return e; + } + if (p->analysis_stats) { + e = (*v)(p->analysis_stats, a); if (e) return e; + } + if (p->factorize_stats) { + e = (*v)(p->factorize_stats, a); if (e) return e; + } + if (p->solve_stats) { + e = (*v)(p->solve_stats, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)o; + tmp = ((PyObject*)p->icntl); + p->icntl = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->info); + p->info = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->infog); + p->infog = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->cntl); + p->cntl = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfo); + p->rinfo = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfog); + p->rinfog = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->analysis_stats); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->factorize_stats); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->solve_stats); + p->solve_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_analyzed(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8analyzed_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_factorized(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10factorized_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3sym_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_par(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_par(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3par_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_job(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_job(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3job_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_comm_fortran(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_comm_fortran(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12comm_fortran_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_icntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5icntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_n(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_n(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1n_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_alloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_alloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8nz_alloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_2nz_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3irn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3jcn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7irn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7jcn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nelt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nelt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nelt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltvar(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltvar(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6eltvar_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_perm_in(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_perm_in(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7perm_in_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8sym_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_uns_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_uns_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8uns_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11irhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_ptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_ptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8irhs_ptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_isol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_isol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8isol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4nrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4lrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lredrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lredrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7lredrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nz_rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lsol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lsol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lsol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_mloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_mloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_mloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_nloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_nloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10schur_nloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_lld(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_lld(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9schur_lld_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6mblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6nblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nprow(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nprow(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5nprow_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_npcol(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_npcol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5npcol_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_info(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4info_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_infog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5infog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_deficiency(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_deficiency(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10deficiency_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_pivnul_list(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_pivnul_list(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11pivnul_list_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mapping(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mapping(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7mapping_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_size_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_size_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10size_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_listvar_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_listvar_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13listvar_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_instance_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_instance_number(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_15instance_number_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_version_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_14version_number_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_tmpdir(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_tmpdir(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_tmpdir_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_prefix(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_prefix(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10ooc_prefix_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_write_problem(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_write_problem(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13write_problem_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lwk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lwk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8lwk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_cntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4cntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_1a_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_elt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_elt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5a_elt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_colsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_colsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6colsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rowsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rowsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rowsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_3rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_redrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_redrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6redrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10rhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7sol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rinfo(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5rinfo_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rinfog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6rinfog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_wk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_wk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7wk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64[] = { + {"set_silent", (PyCFunction)__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_5set_silent, METH_NOARGS, __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_4set_silent}, + {"analyze", (PyCFunction)__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_7analyze, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_6analyze}, + {"factorize", (PyCFunction)__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_9factorize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_8factorize}, + {"solve", (PyCFunction)__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_11solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_10solve}, + {"refine", (PyCFunction)__pyx_pw_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_13refine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_12refine}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64[] = { + {(char *)"analyzed", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_analyzed, 0, 0, 0}, + {(char *)"factorized", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_factorized, 0, 0, 0}, + {(char *)"sym", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym, 0, 0}, + {(char *)"par", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_par, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_par, 0, 0}, + {(char *)"job", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_job, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_job, 0, 0}, + {(char *)"comm_fortran", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_comm_fortran, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_comm_fortran, 0, 0}, + {(char *)"icntl", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_icntl, 0, 0, 0}, + {(char *)"n", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_n, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_n, 0, 0}, + {(char *)"nz_alloc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_alloc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_alloc, 0, 0}, + {(char *)"nz", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz, 0, 0}, + {(char *)"irn", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn, 0, 0}, + {(char *)"jcn", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn, 0, 0}, + {(char *)"nz_loc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_loc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_loc, 0, 0}, + {(char *)"irn_loc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn_loc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irn_loc, 0, 0}, + {(char *)"jcn_loc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn_loc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_jcn_loc, 0, 0}, + {(char *)"nelt", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nelt, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nelt, 0, 0}, + {(char *)"eltptr", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltptr, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltptr, 0, 0}, + {(char *)"eltvar", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltvar, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_eltvar, 0, 0}, + {(char *)"perm_in", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_perm_in, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_perm_in, 0, 0}, + {(char *)"sym_perm", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym_perm, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sym_perm, 0, 0}, + {(char *)"uns_perm", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_uns_perm, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_uns_perm, 0, 0}, + {(char *)"irhs_sparse", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_sparse, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_sparse, 0, 0}, + {(char *)"irhs_ptr", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_ptr, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_irhs_ptr, 0, 0}, + {(char *)"isol_loc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_isol_loc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_isol_loc, 0, 0}, + {(char *)"nrhs", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nrhs, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nrhs, 0, 0}, + {(char *)"lrhs", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lrhs, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lrhs, 0, 0}, + {(char *)"lredrhs", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lredrhs, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lredrhs, 0, 0}, + {(char *)"nz_rhs", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_rhs, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nz_rhs, 0, 0}, + {(char *)"lsol_loc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lsol_loc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lsol_loc, 0, 0}, + {(char *)"schur_mloc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_mloc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_mloc, 0, 0}, + {(char *)"schur_nloc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_nloc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_nloc, 0, 0}, + {(char *)"schur_lld", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_lld, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur_lld, 0, 0}, + {(char *)"mblock", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mblock, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mblock, 0, 0}, + {(char *)"nblock", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nblock, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nblock, 0, 0}, + {(char *)"nprow", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nprow, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_nprow, 0, 0}, + {(char *)"npcol", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_npcol, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_npcol, 0, 0}, + {(char *)"info", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_info, 0, 0, 0}, + {(char *)"infog", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_infog, 0, 0, 0}, + {(char *)"deficiency", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_deficiency, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_deficiency, 0, 0}, + {(char *)"pivnul_list", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_pivnul_list, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_pivnul_list, 0, 0}, + {(char *)"mapping", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mapping, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mapping, 0, 0}, + {(char *)"size_schur", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_size_schur, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_size_schur, 0, 0}, + {(char *)"listvar_schur", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_listvar_schur, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_listvar_schur, 0, 0}, + {(char *)"instance_number", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_instance_number, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_instance_number, 0, 0}, + {(char *)"version_number", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_version_number, 0, 0, 0}, + {(char *)"ooc_tmpdir", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_tmpdir, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_tmpdir, 0, 0}, + {(char *)"ooc_prefix", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_prefix, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_ooc_prefix, 0, 0}, + {(char *)"write_problem", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_write_problem, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_write_problem, 0, 0}, + {(char *)"lwk_user", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lwk_user, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_lwk_user, 0, 0}, + {(char *)"cntl", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_cntl, 0, 0, 0}, + {(char *)"a", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a, 0, 0}, + {(char *)"a_loc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_loc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_loc, 0, 0}, + {(char *)"a_elt", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_elt, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_a_elt, 0, 0}, + {(char *)"colsca", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_colsca, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_colsca, 0, 0}, + {(char *)"rowsca", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rowsca, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rowsca, 0, 0}, + {(char *)"rhs", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs, 0, 0}, + {(char *)"redrhs", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_redrhs, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_redrhs, 0, 0}, + {(char *)"rhs_sparse", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs_sparse, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rhs_sparse, 0, 0}, + {(char *)"sol_loc", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sol_loc, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_sol_loc, 0, 0}, + {(char *)"rinfo", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rinfo, 0, 0, 0}, + {(char *)"rinfog", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_rinfog, 0, 0, 0}, + {(char *)"schur", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_schur, 0, 0}, + {(char *)"wk_user", __pyx_getprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_wk_user, __pyx_setprop_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_wk_user, 0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX64.BaseMUMPSSolver_INT32_COMPLEX64", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n Base MUMPS Context.\n\n This version **only** deals with array pointers.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *__pyx_freelist_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve[8]; +static int __pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve[--__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve(PyObject *o) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_kwargs); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve)))) { + __pyx_freelist_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve[__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve++] = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *)o; + if (p->__pyx_v_kwargs) { + e = (*v)(p->__pyx_v_kwargs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *)o; + tmp = ((PyObject*)p->__pyx_v_kwargs); + p->__pyx_v_kwargs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX64.__pyx_scope_struct__solve", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *__pyx_freelist_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr[8]; +static int __pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr[--__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_arg); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr)))) { + __pyx_freelist_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr[__pyx_freecount_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject*)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_arg) { + e = (*v)(p->__pyx_v_arg, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr *)o; + tmp = ((PyObject*)p->__pyx_outer_scope); + p->__pyx_outer_scope = ((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_arg); + p->__pyx_v_arg = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_COMPLEX64.__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "mumps_INT32_COMPLEX64", + __pyx_k_This_is_the_base_class_for_the, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_AnalysisStatistics, __pyx_k_AnalysisStatistics, sizeof(__pyx_k_AnalysisStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_FactorizationStatistics, __pyx_k_FactorizationStatistics, sizeof(__pyx_k_FactorizationStatistics), 0, 0, 1, 1}, + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError, __pyx_k_MUMPSError, sizeof(__pyx_k_MUMPSError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError___init, __pyx_k_MUMPSError___init, sizeof(__pyx_k_MUMPSError___init), 0, 0, 1, 1}, + {&__pyx_kp_s_MUMPS_error, __pyx_k_MUMPS_error, sizeof(__pyx_k_MUMPS_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_failed_with_error, __pyx_k_MUMPS_failed_with_error, sizeof(__pyx_k_MUMPS_failed_with_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st, __pyx_k_MUMPS_index_must_be_1_Fortran_st, sizeof(__pyx_k_MUMPS_index_must_be_1_Fortran_st), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_d, __pyx_k_MUMPS_index_must_be_d, sizeof(__pyx_k_MUMPS_index_must_be_d), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_numerically_singular, __pyx_k_Matrix_is_numerically_singular, sizeof(__pyx_k_Matrix_is_numerically_singular), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_singular_in_structure, __pyx_k_Matrix_is_singular_in_structure, sizeof(__pyx_k_Matrix_is_singular_in_structure), 0, 0, 1, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_kp_s_Not_enough_memory, __pyx_k_Not_enough_memory, sizeof(__pyx_k_Not_enough_memory), 0, 0, 1, 0}, + {&__pyx_kp_s_Not_enough_memory_during_analysi, __pyx_k_Not_enough_memory_during_analysi, sizeof(__pyx_k_Not_enough_memory_during_analysi), 0, 0, 1, 0}, + {&__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_k_Only_one_dense_rhs_is_allowed_fo, sizeof(__pyx_k_Only_one_dense_rhs_is_allowed_fo), 0, 0, 1, 0}, + {&__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_k_Right_hand_side_has_wrong_sizeAt, sizeof(__pyx_k_Right_hand_side_has_wrong_sizeAt), 0, 0, 1, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_SolveStatistics, __pyx_k_SolveStatistics, sizeof(__pyx_k_SolveStatistics), 0, 0, 1, 1}, + {&__pyx_kp_s_The_authors_of_MUMPS_would_like, __pyx_k_The_authors_of_MUMPS_would_like, sizeof(__pyx_k_The_authors_of_MUMPS_would_like), 0, 0, 1, 0}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_k_Users_syarra_work_VirtualEnvs_n, sizeof(__pyx_k_Users_syarra_work_VirtualEnvs_n), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_amd, __pyx_k_amd, sizeof(__pyx_k_amd), 0, 0, 1, 1}, + {&__pyx_n_s_amf, __pyx_k_amf, sizeof(__pyx_k_amf), 0, 0, 1, 1}, + {&__pyx_n_s_analyze, __pyx_k_analyze, sizeof(__pyx_k_analyze), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_n_s_asfortranarray, __pyx_k_asfortranarray, sizeof(__pyx_k_asfortranarray), 0, 0, 1, 1}, + {&__pyx_n_s_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 0, 1, 1}, + {&__pyx_n_s_clock, __pyx_k_clock, sizeof(__pyx_k_clock), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_complex64, __pyx_k_complex64, sizeof(__pyx_k_complex64), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_error_messages, __pyx_k_error_messages, sizeof(__pyx_k_error_messages), 0, 0, 1, 1}, + {&__pyx_n_s_factorize, __pyx_k_factorize, sizeof(__pyx_k_factorize), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_infog, __pyx_k_infog, sizeof(__pyx_k_infog), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_metis, __pyx_k_metis, sizeof(__pyx_k_metis), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_mumps_statistics, __pyx_k_mumps_mumps_statistics, sizeof(__pyx_k_mumps_mumps_statistics), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_src_mumps_INT32_COMPLEX64, __pyx_k_mumps_src_mumps_INT32_COMPLEX64, sizeof(__pyx_k_mumps_src_mumps_INT32_COMPLEX64), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_nitref, __pyx_k_nitref, sizeof(__pyx_k_nitref), 0, 0, 1, 1}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_ordering, __pyx_k_ordering, sizeof(__pyx_k_ordering), 0, 0, 1, 1}, + {&__pyx_n_s_ordering_name, __pyx_k_ordering_name, sizeof(__pyx_k_ordering_name), 0, 0, 1, 1}, + {&__pyx_n_s_orderings, __pyx_k_orderings, sizeof(__pyx_k_orderings), 0, 0, 1, 1}, + {&__pyx_n_s_pivot_tol, __pyx_k_pivot_tol, sizeof(__pyx_k_pivot_tol), 0, 0, 1, 1}, + {&__pyx_n_s_pord, __pyx_k_pord, sizeof(__pyx_k_pord), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_qamd, __pyx_k_qamd, sizeof(__pyx_k_qamd), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_kp_s_refinement, __pyx_k_refinement, sizeof(__pyx_k_refinement), 0, 0, 1, 0}, + {&__pyx_n_s_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_col_ptr, __pyx_k_rhs_col_ptr, sizeof(__pyx_k_rhs_col_ptr), 0, 0, 1, 1}, + {&__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP, __pyx_k_rhs_dense_arrays_must_be_an_NumP, sizeof(__pyx_k_rhs_dense_arrays_must_be_an_NumP), 0, 0, 1, 0}, + {&__pyx_kp_s_rhs_not_given_in_the_right_forma, __pyx_k_rhs_not_given_in_the_right_forma, sizeof(__pyx_k_rhs_not_given_in_the_right_forma), 0, 0, 1, 0}, + {&__pyx_n_s_rhs_row_ind, __pyx_k_rhs_row_ind, sizeof(__pyx_k_rhs_row_ind), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_val, __pyx_k_rhs_val, sizeof(__pyx_k_rhs_val), 0, 0, 1, 1}, + {&__pyx_n_s_scotch, __pyx_k_scotch, sizeof(__pyx_k_scotch), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, + {&__pyx_n_s_set_silent, __pyx_k_set_silent, sizeof(__pyx_k_set_silent), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, + {&__pyx_n_s_solve_locals_genexpr, __pyx_k_solve_locals_genexpr, sizeof(__pyx_k_solve_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, + {&__pyx_n_s_tol, __pyx_k_tol, sizeof(__pyx_k_tol), 0, 0, 1, 1}, + {&__pyx_n_s_transpose_solve, __pyx_k_transpose_solve, sizeof(__pyx_k_transpose_solve), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_kp_s_user_defined, __pyx_k_user_defined, sizeof(__pyx_k_user_defined), 0, 0, 1, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_tuple__3 = PyTuple_Pack(3, __pyx_n_s_rhs_col_ptr, __pyx_n_s_rhs_row_ind, __pyx_n_s_rhs_val); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_rhs_not_given_in_the_right_forma); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_tuple__13 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_infog, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_n_s_init, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_float_0_01 = PyFloat_FromDouble(0.01); if (unlikely(!__pyx_float_0_01)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_5 = PyInt_FromLong(-5); if (unlikely(!__pyx_int_neg_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_6 = PyInt_FromLong(-6); if (unlikely(!__pyx_int_neg_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_7 = PyInt_FromLong(-7); if (unlikely(!__pyx_int_neg_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_8 = PyInt_FromLong(-8); if (unlikely(!__pyx_int_neg_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_9 = PyInt_FromLong(-9); if (unlikely(!__pyx_int_neg_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_10 = PyInt_FromLong(-10); if (unlikely(!__pyx_int_neg_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_11 = PyInt_FromLong(-11); if (unlikely(!__pyx_int_neg_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_12 = PyInt_FromLong(-12); if (unlikely(!__pyx_int_neg_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_13 = PyInt_FromLong(-13); if (unlikely(!__pyx_int_neg_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initmumps_INT32_COMPLEX64(void); /*proto*/ +PyMODINIT_FUNC initmumps_INT32_COMPLEX64(void) +#else +PyMODINIT_FUNC PyInit_mumps_INT32_COMPLEX64(void); /*proto*/ +PyMODINIT_FUNC PyInit_mumps_INT32_COMPLEX64(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_mumps_INT32_COMPLEX64(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("mumps_INT32_COMPLEX64", __pyx_methods, __pyx_k_This_is_the_base_class_for_the, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__mumps_INT32_COMPLEX64) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.mumps_INT32_COMPLEX64")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.mumps_INT32_COMPLEX64", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("c_to_fortran_index_array", (void (*)(void))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Type init code ---*/ + __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array = &__pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array.tp_dict, __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "mumps_int_array", (PyObject *)&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array = &__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; + __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array = &__pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *, CMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array.tp_dict, __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "cmumps_real_array", (PyObject *)&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array = &__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; + __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 = &__pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.get_data_pointers = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, MUMPS_INT *, MUMPS_INT *, CMUMPS_COMPLEX *))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_get_data_pointers; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.initialize_mumps_struct = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, PyObject *, PyObject *))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_initialize_mumps_struct; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.mumps_call = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_mumps_call; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.set_centralized_assembled_matrix = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_set_centralized_assembled_matrix; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.solve_dense = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, CMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_solve_dense; + __pyx_vtable_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.solve_sparse = (PyObject *(*)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, MUMPS_INT *, MUMPS_INT *, CMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, CMUMPS_COMPLEX *, MUMPS_INT))__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_31BaseMUMPSSolver_INT32_COMPLEX64_solve_sparse; + if (PyType_Ready(&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64.tp_dict, __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "BaseMUMPSSolver_INT32_COMPLEX64", (PyObject *)&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 = &__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + if (PyType_Ready(&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve.tp_print = 0; + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve = &__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct__solve; + if (PyType_Ready(&__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr.tp_print = 0; + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr = &__pyx_type_5mumps_3src_21mumps_INT32_COMPLEX64___pyx_scope_struct_1_genexpr; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":88 + * """ + * + * from mumps.mumps_statistics import AnalysisStatistics, FactorizationStatistics, SolveStatistics # <<<<<<<<<<<<<< + * + * from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free + */ + __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_AnalysisStatistics); + __Pyx_GIVEREF(__pyx_n_s_AnalysisStatistics); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_AnalysisStatistics); + __Pyx_INCREF(__pyx_n_s_FactorizationStatistics); + __Pyx_GIVEREF(__pyx_n_s_FactorizationStatistics); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_FactorizationStatistics); + __Pyx_INCREF(__pyx_n_s_SolveStatistics); + __Pyx_GIVEREF(__pyx_n_s_SolveStatistics); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_SolveStatistics); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_mumps_mumps_statistics, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AnalysisStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AnalysisStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FactorizationStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FactorizationStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SolveStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SolveStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":96 + * from libc.string cimport strncpy + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":99 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * import time + */ + import_array(); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":101 + * cnp.import_array() + * + * import time # <<<<<<<<<<<<<< + * + * cdef extern from "mumps_c_types.h": + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":214 + * + * # MUMPS possible ordering methods + * orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, # <<<<<<<<<<<<<< + * 'qamd' : 6, 'auto' : 7 } + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amd, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amf, __pyx_int_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scotch, __pyx_int_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_pord, __pyx_int_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_metis, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_qamd, __pyx_int_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_auto, __pyx_int_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_orderings, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":217 + * 'qamd' : 6, 'auto' : 7 } + * + * ordering_name = [ 'amd', 'user-defined', 'amf', # <<<<<<<<<<<<<< + * 'scotch', 'pord', 'metis', 'qamd'] + * + */ + __pyx_t_2 = PyList_New(7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_amd); + __Pyx_GIVEREF(__pyx_n_s_amd); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_amd); + __Pyx_INCREF(__pyx_kp_s_user_defined); + __Pyx_GIVEREF(__pyx_kp_s_user_defined); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_kp_s_user_defined); + __Pyx_INCREF(__pyx_n_s_amf); + __Pyx_GIVEREF(__pyx_n_s_amf); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_amf); + __Pyx_INCREF(__pyx_n_s_scotch); + __Pyx_GIVEREF(__pyx_n_s_scotch); + PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_scotch); + __Pyx_INCREF(__pyx_n_s_pord); + __Pyx_GIVEREF(__pyx_n_s_pord); + PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_pord); + __Pyx_INCREF(__pyx_n_s_metis); + __Pyx_GIVEREF(__pyx_n_s_metis); + PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_metis); + __Pyx_INCREF(__pyx_n_s_qamd); + __Pyx_GIVEREF(__pyx_n_s_qamd); + PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_qamd); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ordering_name, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":223 + * # TODO: decouple + * error_messages = { + * -5 : "Not enough memory during analysis phase", # <<<<<<<<<<<<<< + * -6 : "Matrix is singular in structure", + * -7 : "Not enough memory during analysis phase", + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_5, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_6, __pyx_kp_s_Matrix_is_singular_in_structure) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_7, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_10, __pyx_kp_s_Matrix_is_numerically_singular) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_11, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_12, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_13, __pyx_kp_s_Not_enough_memory) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_error_messages, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_builtin_RuntimeError); + __Pyx_GIVEREF(__pyx_builtin_RuntimeError); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_RuntimeError); + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_MUMPSError, __pyx_n_s_MUMPSError, (PyObject *) NULL, __pyx_n_s_mumps_src_mumps_INT32_COMPLEX64, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5mumps_3src_21mumps_INT32_COMPLEX64_10MUMPSError_1__init__, 0, __pyx_n_s_MUMPSError___init, NULL, __pyx_n_s_mumps_src_mumps_INT32_COMPLEX64, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_init, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MUMPSError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MUMPSError, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_COMPLEX64.pyx":1 + * """ # <<<<<<<<<<<<<< + * This is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home) + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.mumps_INT32_COMPLEX64", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.mumps_INT32_COMPLEX64"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return NULL; + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#endif + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return -1; + } + } + return m->sq_ass_item(o, i, v); + } + } +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) { +#else + if (is_list || PySequence_Check(o)) { +#endif + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15 + default: return PyLong_Type.tp_richcompare(op1, op2, Py_EQ); + #else + default: Py_RETURN_FALSE; + #endif + } + } + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + return PyObject_RichCompare(op1, op2, Py_EQ); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); +#else + if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } else { + if (default_value == Py_None) + default_value = NULL; + value = PyObject_CallMethodObjArgs( + d, __pyx_n_s_get, key, default_value, NULL); + } +#endif + return value; +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_COMPILING_IN_CPYTHON + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyMem_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +#if CYTHON_COMPILING_IN_PYPY +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + PyObject *self = f->m_self; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0 = PySequence_ITEM(arg, 0); + if (unlikely(!arg0)) return NULL; + result = (*meth)(self, arg0); + Py_DECREF(arg0); + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +#else +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return PyCFunction_Call(func, arg, kw); +} +#endif +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_Call, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { +#if !CYTHON_COMPILING_IN_PYPY + __pyx_CyFunctionType_type.tp_call = PyCFunction_Call; +#endif + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (__pyx_CyFunctionType == NULL) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyMem_Malloc(size); + if (!m->defaults) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(MUMPS_INT) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(MUMPS_INT), + little, !is_unsigned); + } +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; +#else + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); +#endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto bad; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + args = PyTuple_New(2); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +bad: + Py_XDECREF(method); + return result; +} + +#include +#include +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { +#if PY_VERSION_HEX >= 0x030300A0 + if (ev && Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } +#endif + if (!ev || !PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + ev = Py_None; + } else if (PyTuple_Check(ev)) { + if (PyTuple_GET_SIZE(ev) >= 1) { + PyObject *value; +#if CYTHON_COMPILING_IN_CPYTHON + value = PySequence_ITEM(ev, 0); +#else + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#endif + Py_DECREF(ev); + ev = value; + } else { + Py_INCREF(Py_None); + Py_DECREF(ev); + ev = Py_None; + } + } + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = ev; + return 0; + } + } else if (!PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if PY_VERSION_HEX >= 0x030300A0 + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); +#else + { + PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); + Py_DECREF(ev); + if (likely(args)) { + value = PySequence_GetItem(args, 0); + Py_DECREF(args); + } + if (unlikely(!value)) { + __Pyx_ErrRestore(NULL, NULL, NULL); + Py_INCREF(Py_None); + value = Py_None; + } + } +#endif + *pvalue = value; + return 0; +} +#endif +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__pyx_CoroutineObject *self) { + PyObject *exc_type = self->exc_type; + PyObject *exc_value = self->exc_value; + PyObject *exc_traceback = self->exc_traceback; + self->exc_type = NULL; + self->exc_value = NULL; + self->exc_traceback = NULL; + Py_XDECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_traceback); +} +static CYTHON_INLINE +int __Pyx_Coroutine_CheckRunning(__pyx_CoroutineObject *gen) { + if (unlikely(gen->is_running)) { + PyErr_SetString(PyExc_ValueError, + "generator already executing"); + return 1; + } + return 0; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) { + PyObject *retval; + assert(!self->is_running); + if (unlikely(self->resume_label == 0)) { + if (unlikely(value && value != Py_None)) { + PyErr_SetString(PyExc_TypeError, + "can't send non-None value to a " + "just-started generator"); + return NULL; + } + } + if (unlikely(self->resume_label == -1)) { + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } + if (value) { +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyThreadState *tstate = PyThreadState_GET(); + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_XINCREF(tstate->frame); + assert(f->f_back == NULL); + f->f_back = tstate->frame; + } +#endif + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + self->is_running = 1; + retval = self->body((PyObject *) self, value); + self->is_running = 0; + if (retval) { + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + } +#endif + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_MethodReturn(PyObject *retval) { + if (unlikely(!retval && !PyErr_Occurred())) { + PyErr_SetNone(PyExc_StopIteration); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { + PyObject *ret; + PyObject *val = NULL; + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen_FetchStopIterationValue(&val); + ret = __Pyx_Coroutine_SendEx(gen, val); + Py_XDECREF(val); + return ret; +} +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + { + if (value == Py_None) + ret = PyIter_Next(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + } + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + retval = __Pyx_Coroutine_FinishDelegation(gen); + } else { + retval = __Pyx_Coroutine_SendEx(gen, value); + } + return __Pyx_Coroutine_MethodReturn(retval); +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + PyObject *retval = NULL; + int err = 0; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + { + PyObject *meth; + gen->is_running = 1; + meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + if (unlikely(!meth)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_WriteUnraisable(yf); + } + PyErr_Clear(); + } else { + retval = PyObject_CallFunction(meth, NULL); + Py_DECREF(meth); + if (!retval) + err = -1; + } + gen->is_running = 0; + } + Py_XDECREF(retval); + return err; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + ret = Py_TYPE(yf)->tp_iternext(yf); + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + return __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_SendEx(gen, Py_None); +} +static PyObject *__Pyx_Coroutine_Close(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *retval, *raised_exception; + PyObject *yf = gen->yieldfrom; + int err = 0; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + retval = __Pyx_Coroutine_SendEx(gen, NULL); + if (retval) { + Py_DECREF(retval); + PyErr_SetString(PyExc_RuntimeError, + "generator ignored GeneratorExit"); + return NULL; + } + raised_exception = PyErr_Occurred(); + if (!raised_exception + || raised_exception == PyExc_StopIteration + || raised_exception == PyExc_GeneratorExit + || PyErr_GivenExceptionMatches(raised_exception, PyExc_GeneratorExit) + || PyErr_GivenExceptionMatches(raised_exception, PyExc_StopIteration)) + { + if (raised_exception) PyErr_Clear(); + Py_INCREF(Py_None); + return Py_None; + } + return NULL; +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *typ; + PyObject *tb = NULL; + PyObject *val = NULL; + PyObject *yf = gen->yieldfrom; + if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + return NULL; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + Py_INCREF(yf); + if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit)) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); + goto throw_here; + } + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + { + PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + gen->is_running = 0; + return NULL; + } + PyErr_Clear(); + __Pyx_Coroutine_Undelegate(gen); + gen->is_running = 0; + goto throw_here; + } + ret = PyObject_CallObject(meth, args); + Py_DECREF(meth); + } + gen->is_running = 0; + Py_DECREF(yf); + if (!ret) { + ret = __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_MethodReturn(ret); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); +} +static int __Pyx_Coroutine_traverse(PyObject *self, visitproc visit, void *arg) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + Py_VISIT(gen->exc_type); + Py_VISIT(gen->exc_value); + Py_VISIT(gen->exc_traceback); + return 0; +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + Py_CLEAR(gen->yieldfrom); + Py_CLEAR(gen->exc_type); + Py_CLEAR(gen->exc_value); + Py_CLEAR(gen->exc_traceback); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label > 0) { + PyObject_GC_Track(self); +#if PY_VERSION_HEX >= 0x030400a1 + if (PyObject_CallFinalizerFromDealloc(self)) +#else + Py_TYPE(gen)->tp_del(self); + if (self->ob_refcnt > 0) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } + __Pyx_Coroutine_clear(self); + PyObject_GC_Del(gen); +} +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *res; + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + if (gen->resume_label <= 0) + return ; +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt == 0); + self->ob_refcnt = 1; +#endif + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + res = __Pyx_Coroutine_Close(self); + if (res == NULL) + PyErr_WriteUnraisable(self); + else + Py_DECREF(res); + __Pyx_ErrRestore(error_type, error_value, error_traceback); +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt > 0); + if (--self->ob_refcnt == 0) { + return; + } + { + Py_ssize_t refcnt = self->ob_refcnt; + _Py_NewReference(self); + self->ob_refcnt = refcnt; + } +#if CYTHON_COMPILING_IN_CPYTHON + assert(PyType_IS_GC(self->ob_type) && + _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); + _Py_DEC_REFTOTAL; +#endif +#ifdef COUNT_ALLOCS + --Py_TYPE(self)->tp_frees; + --Py_TYPE(self)->tp_allocs; +#endif +#endif +} +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_name); + return self->gi_name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = self->gi_name; + Py_INCREF(value); + self->gi_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_qualname); + return self->gi_qualname; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = self->gi_qualname; + Py_INCREF(value); + self->gi_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject* type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (gen == NULL) + return NULL; + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->exc_type = NULL; + gen->exc_value = NULL; + gen->exc_traceback = NULL; + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + PyObject_GC_Track(gen); + return gen; +} + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + int result; + PyObject *globals, *result_obj; + globals = PyDict_New(); if (unlikely(!globals)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_coroutine_type", + #ifdef __Pyx_Coroutine_USED + (PyObject*)__pyx_CoroutineType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_generator_type", + #ifdef __Pyx_Generator_USED + (PyObject*)__pyx_GeneratorType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; + result_obj = PyRun_String(py_code, Py_file_input, globals, globals); + if (unlikely(!result_obj)) goto ignore; + Py_DECREF(result_obj); + Py_DECREF(globals); + return module; +ignore: + Py_XDECREF(globals); + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + py_code++; +#endif + return module; +} + +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) +static PyObject* __Pyx_patch_abc_module(PyObject *module); +static PyObject* __Pyx_patch_abc_module(PyObject *module) { + module = __Pyx_Coroutine_patch_module( + module, "" +"if _cython_generator_type is not None:\n" +" try: Generator = _module.Generator\n" +" except AttributeError: pass\n" +" else: Generator.register(_cython_generator_type)\n" +"if _cython_coroutine_type is not None:\n" +" try: Coroutine = _module.Coroutine\n" +" except AttributeError: pass\n" +" else: Coroutine.register(_cython_coroutine_type)\n" + ); + return module; +} +#endif +static int __Pyx_patch_abc(void) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + static int abc_patched = 0; + if (!abc_patched) { + PyObject *module; + module = PyImport_ImportModule((PY_VERSION_HEX >= 0x03030000) ? "collections.abc" : "collections"); + if (!module) { + PyErr_WriteUnraisable(NULL); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, + ((PY_VERSION_HEX >= 0x03030000) ? + "Cython module failed to register with collections.abc module" : + "Cython module failed to register with collections module"), 1) < 0)) { + return -1; + } + } else { + module = __Pyx_patch_abc_module(module); + abc_patched = 1; + if (unlikely(!module)) + return -1; + Py_DECREF(module); + } + module = PyImport_ImportModule("backports_abc"); + if (module) { + module = __Pyx_patch_abc_module(module); + Py_XDECREF(module); + } + if (!module) { + PyErr_Clear(); + } + } +#else + if (0) __Pyx_Coroutine_patch_module(NULL, NULL); +#endif + return 0; +} + +static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the generator"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the generator"), 0}, + {0, 0, 0, 0, 0} +}; +static PyTypeObject __pyx_GeneratorType_type = { + PyVarObject_HEAD_INIT(0, 0) + "generator", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, + 0, + offsetof(__pyx_CoroutineObject, gi_weakreflist), + 0, + (iternextfunc) __Pyx_Generator_Next, + __pyx_Generator_methods, + __pyx_Generator_memberlist, + __pyx_Generator_getsets, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if PY_VERSION_HEX >= 0x030400a1 + __Pyx_Coroutine_del, +#endif +}; +static int __pyx_Generator_init(void) { + __pyx_GeneratorType_type.tp_getattro = PyObject_GenericGetAttr; + __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; + __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); + if (unlikely(!__pyx_GeneratorType)) { + return -1; + } + return 0; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0) + goto bad; + } + tmp.fp = f; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/mumps_INT32_COMPLEX64.pxd b/mumps/src/mumps_INT32_COMPLEX64.pxd new file mode 100644 index 0000000..a391fc3 --- /dev/null +++ b/mumps/src/mumps_INT32_COMPLEX64.pxd @@ -0,0 +1,186 @@ +cimport numpy as cnp + +cdef extern from "mumps_c_types.h": + + ctypedef int MUMPS_INT + ctypedef cnp.int8_t MUMPS_INT8 + + ctypedef float SMUMPS_COMPLEX + ctypedef float SMUMPS_REAL + + ctypedef double DMUMPS_COMPLEX + ctypedef double DMUMPS_REAL + + ctypedef struct mumps_complex: + float r,i + + ctypedef mumps_complex CMUMPS_COMPLEX + ctypedef float CMUMPS_REAL + + ctypedef struct mumps_double_complex: + double r, i + + ctypedef mumps_double_complex ZMUMPS_COMPLEX + ctypedef double ZMUMPS_REAL + +cdef extern from "cmumps_c.h": + ctypedef struct CMUMPS_STRUC_C: + MUMPS_INT sym, par, job + MUMPS_INT comm_fortran # Fortran communicator + MUMPS_INT icntl[40] + MUMPS_INT keep[500] + CMUMPS_REAL cntl[15] + CMUMPS_REAL dkeep[130]; + MUMPS_INT8 keep8[150]; + MUMPS_INT n + + # used in matlab interface to decide if we + # free + malloc when we have large variation + MUMPS_INT nz_alloc + + # Assembled entry + MUMPS_INT nz + MUMPS_INT *irn + MUMPS_INT *jcn + CMUMPS_COMPLEX *a + + # Distributed entry + MUMPS_INT nz_loc + MUMPS_INT *irn_loc + MUMPS_INT *jcn_loc + CMUMPS_COMPLEX *a_loc + + # Element entry + MUMPS_INT nelt + MUMPS_INT *eltptr + MUMPS_INT *eltvar + CMUMPS_COMPLEX *a_elt + + # Ordering, if given by user + MUMPS_INT *perm_in + + # Orderings returned to user + MUMPS_INT *sym_perm # symmetric permutation + MUMPS_INT *uns_perm # column permutation + + # Scaling (input only in this version) + CMUMPS_REAL *colsca + CMUMPS_REAL *rowsca + MUMPS_INT colsca_from_mumps; + MUMPS_INT rowsca_from_mumps; + + + # RHS, solution, ouptput data and statistics + CMUMPS_COMPLEX *rhs + CMUMPS_COMPLEX *redrhs + CMUMPS_COMPLEX *rhs_sparse + CMUMPS_COMPLEX *sol_loc + MUMPS_INT *irhs_sparse + MUMPS_INT *irhs_ptr + MUMPS_INT *isol_loc + MUMPS_INT nrhs, lrhs, lredrhs, nz_rhs, lsol_loc + MUMPS_INT schur_mloc, schur_nloc, schur_lld + MUMPS_INT mblock, nblock, nprow, npcol + MUMPS_INT info[40] + MUMPS_INT infog[40] + CMUMPS_REAL rinfo[40] + CMUMPS_REAL rinfog[40] + + # Null space + MUMPS_INT deficiency + MUMPS_INT *pivnul_list + MUMPS_INT *mapping + + # Schur + MUMPS_INT size_schur + MUMPS_INT *listvar_schur + CMUMPS_COMPLEX *schur + + # Internal parameters + MUMPS_INT instance_number + CMUMPS_COMPLEX *wk_user + + char *version_number + # For out-of-core + char *ooc_tmpdir + char *ooc_prefix + # To save the matrix in matrix market format + char *write_problem + MUMPS_INT lwk_user + + cdef void cmumps_c(CMUMPS_STRUC_C *) + +cdef class mumps_int_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + int version. + + """ + cdef: + MUMPS_INT * array + int ub + + cdef get_array(self, MUMPS_INT * array, int ub = ?) + +cdef class cmumps_real_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + Real version. + + """ + cdef: + CMUMPS_REAL * array + int ub + + cdef get_array(self, CMUMPS_REAL * array, int ub = ?) + +cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + +cdef class BaseMUMPSSolver_INT32_COMPLEX64: + cdef: + + MUMPS_INT nrow + MUMPS_INT ncol + MUMPS_INT nnz + + # MUMPS + CMUMPS_STRUC_C params + + # internal classes for getters and setters + mumps_int_array icntl + mumps_int_array info + mumps_int_array infog + + cmumps_real_array cntl + cmumps_real_array rinfo + cmumps_real_array rinfog + + MUMPS_INT * a_row + MUMPS_INT * a_col + CMUMPS_COMPLEX * a_val + + bint analyzed + bint factorized + bint out_of_core + + object analysis_stats + object factorize_stats + object solve_stats + + cdef get_data_pointers(self, + MUMPS_INT * a_row, + MUMPS_INT * a_col, + CMUMPS_COMPLEX * a_val) + + cdef initialize_mumps_struct(self, comm_fortran, sym) + + cdef mumps_call(self) + + cdef set_centralized_assembled_matrix(self) + + cdef solve_dense(self, CMUMPS_COMPLEX * rhs, + MUMPS_INT rhs_length, MUMPS_INT nrhs) + cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + CMUMPS_COMPLEX * rhs_val, + MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + CMUMPS_COMPLEX * x, MUMPS_INT x_length) diff --git a/mumps/src/mumps_INT32_COMPLEX64.pyx b/mumps/src/mumps_INT32_COMPLEX64.pyx new file mode 100644 index 0000000..889e508 --- /dev/null +++ b/mumps/src/mumps_INT32_COMPLEX64.pyx @@ -0,0 +1,947 @@ +""" +This is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home) + +""" + +""" +Some notes for the maintainers of this library. + +Basic working: +-------------- + +MUMPS working is simple: + +- initialize/modify the C struct MUMPS_STRUC_C; +- call mumps_c(MUMPS_STRUC_C *). + +For example: + +# analyze +MUMPS_STRUC_C.job = 1 +mumps_c(&MUMPS_STRUC_C) + +# factorize +MUMPS_STRUC_C.job = 2 +mumps_c(&MUMPS_STRUC_C) + +# solve +MUMPS_STRUC_C.job = 3 +mumps_c(&MUMPS_STRUC_C) + +etc. + +Access to: + - icntl + - info + - infog + - cntl + - rinfo + - rinfog + +**must** be done through properties!!!! + + +Typed C struct: +--------------- + +Each MUMPS_STRUC_C is specialized and prefixed by a letter: + +- SMUMPS_STRUC_C: simple precision; +- DMUMPS_STRUC_C: double precision; +- CMUMPS_STRUC_C: simple complex; +- ZMUMPS_STRUC_C: double complex. + +In MUMPSContext_INT32_COMPLEX64, (S,D,C,Z)mumps_c() is called by self.mumps_call(). + + can be used for **ALL** four types. + +Solve: +------ + +MUMPS **overwrites** the rhs member and replaces it by the solution(s) it finds. +If sparse solve is used, the solution is placed in a dummy dense rhs member. + +The rhs member can be a matrix or a vector. + +1-based index arrays: +--------------------- + +MUMPS uses exclusively FORTRAN routines and by consequence **all** array indices start with index **1** (not 0). + +Default 32 bit integers compilation: +------------------------------------ + +By default, MUMPS is compiled in 32 bit integers **unless** it is compiled with the option -DINTSIZE64. +32 and 64 bit versions are **not** compatible. + +Lib creation: +------------- + +The :file:`libmpiseq.so` file is *missing* by default in lib and must be added by hand. It is compiled in directory +libseq. :file:`libmpiseq.so` is essentially a dummy file to deal with sequential code. + +The order in which the library (.so) files are given to construct the MUMPS part +of this interface **is** important... and not standard. + +""" + +from mumps.mumps_statistics import AnalysisStatistics, FactorizationStatistics, SolveStatistics + +from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free +from cpython cimport Py_INCREF, Py_DECREF + +from libc.stdint cimport int64_t +from libc.string cimport strncpy + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + +import time + +cdef extern from "mumps_c_types.h": + + ctypedef int MUMPS_INT + ctypedef int64_t MUMPS_INT8 # warning: mumps uses "stdint.h" which might define int64_t as long long... + + ctypedef float SMUMPS_COMPLEX + ctypedef float SMUMPS_REAL + + ctypedef double DMUMPS_COMPLEX + ctypedef double DMUMPS_REAL + + ctypedef struct mumps_complex: + float r,i + + ctypedef mumps_complex CMUMPS_COMPLEX + ctypedef float CMUMPS_REAL + + ctypedef struct mumps_double_complex: + double r, i + + ctypedef mumps_double_complex ZMUMPS_COMPLEX + ctypedef double ZMUMPS_REAL + +cdef extern from "cmumps_c.h": + ctypedef struct CMUMPS_STRUC_C: + MUMPS_INT sym, par, job + MUMPS_INT comm_fortran # Fortran communicator + MUMPS_INT icntl[40] + MUMPS_INT keep[500] + CMUMPS_REAL cntl[15] + CMUMPS_REAL dkeep[130]; + MUMPS_INT8 keep8[150]; + MUMPS_INT n + + # used in matlab interface to decide if we + # free + malloc when we have large variation + MUMPS_INT nz_alloc + + # Assembled entry + MUMPS_INT nz + MUMPS_INT *irn + MUMPS_INT *jcn + CMUMPS_COMPLEX *a + + # Distributed entry + MUMPS_INT nz_loc + MUMPS_INT *irn_loc + MUMPS_INT *jcn_loc + CMUMPS_COMPLEX *a_loc + + # Element entry + MUMPS_INT nelt + MUMPS_INT *eltptr + MUMPS_INT *eltvar + CMUMPS_COMPLEX *a_elt + + # Ordering, if given by user + MUMPS_INT *perm_in + + # Orderings returned to user + MUMPS_INT *sym_perm # symmetric permutation + MUMPS_INT *uns_perm # column permutation + + # Scaling (input only in this version) + CMUMPS_REAL *colsca + CMUMPS_REAL *rowsca + MUMPS_INT colsca_from_mumps; + MUMPS_INT rowsca_from_mumps; + + + # RHS, solution, ouptput data and statistics + CMUMPS_COMPLEX *rhs + CMUMPS_COMPLEX *redrhs + CMUMPS_COMPLEX *rhs_sparse + CMUMPS_COMPLEX *sol_loc + MUMPS_INT *irhs_sparse + MUMPS_INT *irhs_ptr + MUMPS_INT *isol_loc + MUMPS_INT nrhs, lrhs, lredrhs, nz_rhs, lsol_loc + MUMPS_INT schur_mloc, schur_nloc, schur_lld + MUMPS_INT mblock, nblock, nprow, npcol + MUMPS_INT info[40] + MUMPS_INT infog[40] + CMUMPS_REAL rinfo[40] + CMUMPS_REAL rinfog[40] + + # Null space + MUMPS_INT deficiency + MUMPS_INT *pivnul_list + MUMPS_INT *mapping + + # Schur + MUMPS_INT size_schur + MUMPS_INT *listvar_schur + CMUMPS_COMPLEX *schur + + # Internal parameters + MUMPS_INT instance_number + CMUMPS_COMPLEX *wk_user + + char *version_number + # For out-of-core + char *ooc_tmpdir + char *ooc_prefix + # To save the matrix in matrix market format + char *write_problem + MUMPS_INT lwk_user + + cdef void cmumps_c(CMUMPS_STRUC_C *) + +# MUMPS possible ordering methods +orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, + 'qamd' : 6, 'auto' : 7 } + +ordering_name = [ 'amd', 'user-defined', 'amf', + 'scotch', 'pord', 'metis', 'qamd'] + +# MUMPS ERRORS +# TODO: decouple +error_messages = { + -5 : "Not enough memory during analysis phase", + -6 : "Matrix is singular in structure", + -7 : "Not enough memory during analysis phase", + -10 : "Matrix is numerically singular", + -11 : "The authors of MUMPS would like to hear about this", + -12 : "The authors of MUMPS would like to hear about this", + -13 : "Not enough memory" +} + + +class MUMPSError(RuntimeError): + def __init__(self, infog): + self.error = infog[1] + if self.error in error_messages: + msg = "{}. (MUMPS error {})".format( + error_messages[self.error], self.error) + else: + msg = "MUMPS failed with error {}.".format(self.error) + + RuntimeError.__init__(self, msg) + +# MUMPS HELPERS +cdef class mumps_int_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + + Integer version. + + """ + def __cinit__(self): + pass + + cdef get_array(self, MUMPS_INT * array, int ub = 40): + """ + Args: + ub: upper bound. + """ + self.ub = ub + self.array = array + + def __getitem__(self, key): + if key < 1: + raise IndexError('MUMPS index must be >= 1 (Fortran style)') + if key > self.ub: + raise IndexError('MUMPS index must be <= %d' % self.ub) + + return self.array[key - 1] + + def __setitem__(self, key, value): + self.array[key - 1] = value + +cdef class cmumps_real_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + + Real version. + + """ + def __cinit__(self): + pass + + cdef get_array(self, CMUMPS_REAL * array, int ub = 40): + """ + Args: + ub: upper bound. + """ + self.ub = ub + self.array = array + + def __getitem__(self, key): + if key < 1: + raise IndexError('MUMPS index must be >= 1 (Fortran style)') + if key > self.ub: + raise IndexError('MUMPS index must be <= %d' % self.ub) + + return self.array[key - 1] + + def __setitem__(self, key, value): + self.array[key - 1] = value + + + +cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): + cdef: + MUMPS_INT i + + for i from 0 <= i < a_size: + a[i] += 1 + +# MUMPS CONTEXT +cdef class BaseMUMPSSolver_INT32_COMPLEX64: + """ + Base MUMPS Context. + + This version **only** deals with array pointers. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + """ + + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + """ + self.nrow = n + self.ncol = n + self.nnz = nnz + + assert self.ncol == self.nrow + + self.initialize_mumps_struct(comm_fortran, sym) + + # `initialize_mumps_struct` **must** be called before assigning + # a value to n (size of the matrix) + self.params.n = self.nrow + + self.analyzed = False + self.factorized = False + self.out_of_core = False + + if not verbose: + self.set_silent() + + + cdef initialize_mumps_struct(self, comm_fortran, sym): + """ + Initialize MUMPS structure and make control parameters and information + avalaible to user. + + Args: + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + """ + self.params.job = -1 + self.params.sym = sym + self.params.par = 1 + + self.params.comm_fortran = comm_fortran + + self.mumps_call() + + # integer control parameters + self.icntl = mumps_int_array() + self.icntl.get_array(self.params.icntl) + + # integer information parameters + self.info = mumps_int_array() + self.info.get_array(self.params.info) + + # integer information parameters + self.infog = mumps_int_array() + self.infog.get_array(self.params.infog) + + # real/complex control parameters + self.cntl = cmumps_real_array() + self.cntl.get_array(self.params.cntl) + + # real/complex information parameters + self.rinfo = cmumps_real_array() + self.rinfo.get_array(self.params.rinfo) + + # real/complex information parameters + self.rinfog = cmumps_real_array() + self.rinfog.get_array(self.params.rinfog) + + + cdef get_data_pointers(self, + MUMPS_INT * a_row, + MUMPS_INT * a_col, + CMUMPS_COMPLEX * a_val): + """ + Get elements of A and their positions and transfer them to MUMPS internal structure. + + Args: + a_row: pointer to an MUMPS_INT array containing row indices of non zero elements of A. + a_col: pointer to an MUMPS_INT array containing column indices of non zero elements of A. + a_val: pointer to an MUMPS_INT array containing values of non zeros elements of A. + + Note: row and column indices are adjusted for Fortran indexing. + """ + + self.a_row = a_row + self.a_col = a_col + self.a_val = a_val + + # transform c index arrays to fortran arrays + c_to_fortran_index_array(self.a_row, self.nnz) + c_to_fortran_index_array(self.a_col, self.nnz) + + self.set_centralized_assembled_matrix() + + + cdef set_centralized_assembled_matrix(self): + """ + Set the centralized assembled matrix + The rank 0 process supplies the entire matrix. + """ + + self.params.nz = self.nnz + + self.params.irn = self.a_row + self.params.jcn = self.a_col + self.params.a = self.a_val + + + def __dealloc__(self): + # autodestruct mumps internal + self.params.job = -2 + self.mumps_call() + self.params.job = -1 + self.mumps_call() + + # Properties + # COMMON Properties + property analyzed: + def __get__(self): return self.analyzed + property factorized: + def __get__(self): return self.factorized + property sym: + def __get__(self): return self.params.sym + def __set__(self, value): self.params.sym = value + property par: + def __get__(self): return self.params.par + def __set__(self, value): self.params.par = value + property job: + def __get__(self): return self.params.job + def __set__(self, value): self.params.job = value + + property comm_fortran: + def __get__(self): return self.params.comm_fortran + def __set__(self, value): self.params.comm_fortran = value + + property icntl: + def __get__(self): + return self.icntl + + property n: + def __get__(self): return self.params.n + def __set__(self, value): self.params.n = value + property nz_alloc: + def __get__(self): return self.params.nz_alloc + def __set__(self, value): self.params.nz_alloc = value + + property nz: + def __get__(self): return self.params.nz + def __set__(self, value): self.params.nz = value + property irn: + def __get__(self): return self.params.irn + def __set__(self, long value): self.params.irn = value + property jcn: + def __get__(self): return self.params.jcn + def __set__(self, long value): self.params.jcn = value + + property nz_loc: + def __get__(self): return self.params.nz_loc + def __set__(self, value): self.params.nz_loc = value + property irn_loc: + def __get__(self): return self.params.irn_loc + def __set__(self, long value): self.params.irn_loc = value + property jcn_loc: + def __get__(self): return self.params.jcn_loc + def __set__(self, long value): self.params.jcn_loc = value + + property nelt: + def __get__(self): return self.params.nelt + def __set__(self, value): self.params.nelt = value + property eltptr: + def __get__(self): return self.params.eltptr + def __set__(self, long value): self.params.eltptr = value + property eltvar: + def __get__(self): return self.params.eltvar + def __set__(self, long value): self.params.eltvar = value + + property perm_in: + def __get__(self): return self.params.perm_in + def __set__(self, long value): self.params.perm_in = value + + property sym_perm: + def __get__(self): return self.params.sym_perm + def __set__(self, long value): self.params.sym_perm = value + property uns_perm: + def __get__(self): return self.params.uns_perm + def __set__(self, long value): self.params.uns_perm = value + + property irhs_sparse: + def __get__(self): return self.params.irhs_sparse + def __set__(self, long value): self.params.irhs_sparse = value + property irhs_ptr: + def __get__(self): return self.params.irhs_ptr + def __set__(self, long value): self.params.irhs_ptr = value + property isol_loc: + def __get__(self): return self.params.isol_loc + def __set__(self, long value): self.params.isol_loc = value + + property nrhs: + def __get__(self): return self.params.nrhs + def __set__(self, value): self.params.nrhs = value + property lrhs: + def __get__(self): return self.params.lrhs + def __set__(self, value): self.params.lrhs = value + property lredrhs: + def __get__(self): return self.params.lredrhs + def __set__(self, value): self.params.lredrhs = value + property nz_rhs: + def __get__(self): return self.params.nz_rhs + def __set__(self, value): self.params.nz_rhs = value + property lsol_loc: + def __get__(self): return self.params.lsol_loc + def __set__(self, value): self.params.lsol_loc = value + + property schur_mloc: + def __get__(self): return self.params.schur_mloc + def __set__(self, value): self.params.schur_mloc = value + property schur_nloc: + def __get__(self): return self.params.schur_nloc + def __set__(self, value): self.params.schur_nloc = value + property schur_lld: + def __get__(self): return self.params.schur_lld + def __set__(self, value): self.params.schur_lld = value + + property mblock: + def __get__(self): return self.params.mblock + def __set__(self, value): self.params.mblock = value + property nblock: + def __get__(self): return self.params.nblock + def __set__(self, value): self.params.nblock = value + property nprow: + def __get__(self): return self.params.nprow + def __set__(self, value): self.params.nprow = value + property npcol: + def __get__(self): return self.params.npcol + def __set__(self, value): self.params.npcol = value + + property info: + def __get__(self): + return self.info + + property infog: + def __get__(self): + return self.infog + + property deficiency: + def __get__(self): return self.params.deficiency + def __set__(self, value): self.params.deficiency = value + property pivnul_list: + def __get__(self): return self.params.pivnul_list + def __set__(self, long value): self.params.pivnul_list = value + property mapping: + def __get__(self): return self.params.mapping + def __set__(self, long value): self.params.mapping = value + + property size_schur: + def __get__(self): return self.params.size_schur + def __set__(self, value): self.params.size_schur = value + property listvar_schur: + def __get__(self): return self.params.listvar_schur + def __set__(self, long value): self.params.listvar_schur = value + + property instance_number: + def __get__(self): return self.params.instance_number + def __set__(self, value): self.params.instance_number = value + + property version_number: + def __get__(self): + return ( self.params.version_number).decode('ascii') + + property ooc_tmpdir: + def __get__(self): + return ( self.params.ooc_tmpdir).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + property ooc_prefix: + def __get__(self): + return ( self.params.ooc_prefix).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + + property write_problem: + def __get__(self): + return ( self.params.write_problem).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + + property lwk_user: + def __get__(self): return self.params.lwk_user + def __set__(self, value): self.params.lwk_user = value + + # TYPED Properties + property cntl: + def __get__(self): + return self.cntl + + property a: + def __get__(self): return self.params.a + def __set__(self, long value): self.params.a = value + + property a_loc: + def __get__(self): return self.params.a_loc + def __set__(self, long value): self.params.a_loc = value + + property a_elt: + def __get__(self): return self.params.a_elt + def __set__(self, long value): self.params.a_elt = value + + property colsca: + def __get__(self): return self.params.colsca + def __set__(self, long value): self.params.colsca = value + property rowsca: + def __get__(self): return self.params.rowsca + def __set__(self, long value): self.params.rowsca = value + + property rhs: + def __get__(self): return self.params.rhs + def __set__(self, long value): self.params.rhs = value + property redrhs: + def __get__(self): return self.params.redrhs + def __set__(self, long value): self.params.redrhs = value + property rhs_sparse: + def __get__(self): return self.params.rhs_sparse + def __set__(self, long value): self.params.rhs_sparse = value + property sol_loc: + def __get__(self): return self.params.sol_loc + def __set__(self, long value): self.params.sol_loc = value + + property rinfo: + def __get__(self): + return self.rinfo + + property rinfog: + def __get__(self): + return self.rinfog + + property schur: + def __get__(self): return self.params.schur + def __set__(self, long value): self.params.schur = value + + property wk_user: + def __get__(self): return self.params.wk_user + def __set__(self, long value): self.params.wk_user = value + + # MUMPS CALL + cdef mumps_call(self): + """ + Call to Xmumps_c(XMUMPS_STRUC_C). + """ + cmumps_c(&self.params) + + + def set_silent(self): + """ + Silence **all* MUMPS output. + + See MUMPS documentation. + """ + self.icntl[1] = 0 + self.icntl[2] = 0 + self.icntl[3] = 0 + self.icntl[4] = 0 + + + def analyze(self, ordering='auto'): + """ + Performs analysis step of MUMPS. + + In the analyis step, MUMPS is able to figure out a reordering for the + given matrix. It does so if `ordering` is set to 'auto'. + If not MUMPS will use the provided ordering. + MUMPS statistics for the analysis are available in `analysis_stats`. + + Args: + ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' } + ordering to use in the factorization. The availability of a + particular ordering depends on the MUMPS installation. Default is + 'auto'. + """ + if self.analyzed: + return + + self.icntl[7] = orderings[ordering] + t1 = time.clock() + self.params.job = 1 # analyse + self.mumps_call() + t2 = time.clock() + + if self.infog[1] < 0: + raise MUMPSError(self.infog) + + self.analyzed = True + + # self.analysis_stats = AnalysisStatistics(self.params, + # t2 - t1) + + def factorize(self, ordering='auto', pivot_tol=0.01): + """ + Perform the LU factorization of the matrix (or LDL' if the matrix + is symmetric). + + This factorization can then later be used to solve a linear system + with `solve`. Statistical data of the factorization is stored in + `factor_stats`. + + Args: + ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' } + ordering to use in the factorization. The availability of a + particular ordering depends on the MUMPS installation. Default is + 'auto'. + pivot_tol: number in the range [0, 1] + pivoting threshold. Pivoting is typically limited in sparse + solvers, as too much pivoting destroys sparsity. 1.0 means full + pivoting, whereas 0.0 means no pivoting. Default is 0.01. + """ + # TODO: ordering + + # Analysis phase must be done before factorization + if not self.analyzed : + self.analyze(ordering=ordering) + + self.icntl[22] = 1 if self.out_of_core else 1 + self.cntl[1] = pivot_tol + self.params.job = 2 + + done = False + while not done: + t1 = time.clock() + self.mumps_call() + t2 = time.clock() + + # error -8, -9 (not enough allocated memory) is treated + # specially, by increasing the memory relaxation parameter + if self.infog[1] < 0: + if self.infog[1] in (-8, -9): + # double the additional memory + self.icntl[14] = self.icntl[14]*2 + else: + raise MUMPSError(self.infog) + else: + done = True + + self.factorized = True + # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + + cdef solve_dense(self, CMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): + """ + Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + + Args: + rhs: the right hand side (dense matrix or vector) + rhs_length: Length of each column of the ``rhs``. + nrhs: Number of columns in the matrix ``rhs``. + + Warning: + MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + """ + self.params.nrhs = nrhs + self.params.lrhs = rhs_length + self.params.rhs = rhs + self.params.job = 3 # solve + self.mumps_call() + + cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + CMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + CMUMPS_COMPLEX * x, MUMPS_INT x_length): + """ + Solve a linear system after the LU (or LDL^t) factorization has previously been performed by `factorize` + + Args: + rhs_length: Length of each column of the ``rhs``. + nrhs: Number of columns in the matrix ``rhs``. + overwrite_rhs : ``True`` or ``False`` + whether the data in ``rhs`` may be overwritten, which can lead to a small + performance gain. Default is ``False``. + x : the solution to the linear system as a dense matrix or vector. + x_length: ``self.nrow`` (sequential version). + + Warning: + MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + + """ + self.params.nz_rhs = rhs_nnz + self.params.nrhs = nrhs # nrhs -1 ? + + self.params.rhs_sparse = rhs_val + self.params.irhs_sparse = rhs_row_ind + self.params.irhs_ptr = rhs_col_ptr + + # MUMPS places the solution(s) of the linear system in its dense rhs... + self.params.lrhs = x_length + self.params.rhs = x + + self.params.job = 3 # solve + self.icntl[20] = 1 # tell solver rhs is sparse + self.mumps_call() + + def solve(self, **kwargs): + """ + + Args: + rhs: dense NumPy array (matrix or vector). + rhs_col_ptr, rhs_row_ind, rhs_val: sparse NumPy CSC arrays (matrix or vector). + transpose_solve : ``True`` or ``False`` whether to solve A * x = rhs or A^T * x = rhs. Default is ``False`` + + Returns: + Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + """ + if not self.factorized: + self.factorize() + + transpose_solve = kwargs.get('transpose_solve', False) + self.icntl[9] = 2 if transpose_solve else 1 + + cdef: + MUMPS_INT nrhs + + # rhs can be dense or sparse + if 'rhs' in kwargs: + rhs = kwargs['rhs'] + + if not cnp.PyArray_Check(rhs): + raise TypeError('rhs dense arrays must be an NumPy array') + + # check is dimensions are OK + rhs_shape = rhs.shape + + if (rhs_shape[0] != self.nrow): + raise ValueError("Right hand side has wrong size" + "Attempting to solve the linear system, where A is of size (%d, %d) " + "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + + # create x + x = np.asfortranarray(rhs.copy()) + + # test number of columns in rhs + if rhs.ndim == 1: + nrhs = 1 + else: + nrhs = rhs_shape[1] + + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + + elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + + rhs_col_ptr = kwargs['rhs_col_ptr'] + rhs_row_ind = kwargs['rhs_row_ind'] + rhs_val = kwargs['rhs_val'] + + # fortran indices, done internally in C: no efficiency lost + rhs_col_ptr += 1 + rhs_row_ind += 1 + + nrhs = rhs_col_ptr.size - 1 + x_length = self.nrow + rhs_nnz = rhs_val.size + + x = np.zeros([self.nrow, nrhs], dtype=np.complex64) + + self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + cnp.PyArray_DATA(rhs_val), + rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + else: + raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + + return x + + def refine(self, rhs, nitref = 3, tol=None): + """ + refine(rhs, nitref) performs iterative refinement if necessary + until the scaled residual norm ||b-Ax||/(1+||b||) falls below the + threshold 'tol' or until nitref steps are taken. + Parameters: + nitref : < 0 : Fixed number of steps of iterative refinement. No stopping criterion is used. + 0 : No iterative refinement. + > 0 : Maximum number of steps of iterative refinement. A stopping criterion is used, + therefore a test for convergence is done at each step of the iterative refinement algorithm. + Default: 3 + tol : is the stopping criterion for iterative refinement + + Make sure you have called `solve()` with the same right-hand + side rhs before calling `refine()`. + The residual vector self.residual will be updated to reflect + the updated approximate solution. + """ + cdef: + cnp.npy_intp dim[1] + + if not cnp.PyArray_Check(rhs): + raise TypeError('rhs dense arrays must be an NumPy array') + + # check is dimensions are OK + rhs_shape = rhs.shape + + if (rhs_shape[0] != self.nrow): + raise ValueError("Right hand side has wrong size" + "Attempting to solve the linear system, where A is of size (%d, %d) " + "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + + # test number of columns in rhs. + # Only one rhs is allowed when dense rhs is provided + if rhs.ndim == 1: + nrhs = 1 + else: + raise TypeError("Only one dense rhs is allowed for performing an iterative"+ + "refinement.") + + # create x + x = np.asfortranarray(rhs.copy()) + + self.icntl[10] = nitref + if tol is None: + self.cntl[2] = 0 + else: + self.cntl[2] = tol + + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + + # reset to default values + self.icntl[10] = 0 + self.cntl[2] = -1 + + return x \ No newline at end of file diff --git a/mumps/src/mumps_INT32_FLOAT32.c b/mumps/src/mumps_INT32_FLOAT32.c new file mode 100644 index 0000000..57b3f23 --- /dev/null +++ b/mumps/src/mumps_INT32_FLOAT32.c @@ -0,0 +1,19896 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__mumps_INT32_FLOAT32 +#define __PYX_HAVE_API__mumps__src__mumps_INT32_FLOAT32 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "smumps_c.h" +#include "stdint.h" +#include "pythread.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/mumps_INT32_FLOAT32.pyx", + "__init__.pxd", + "type.pxd", + "bool.pxd", + "complex.pxd", +}; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class smumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":135 + * int ub + * + * cdef get_array(self, SMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":113 + * cdef void smumps_c(SMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class smumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_vtab; + SMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_FLOAT32: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + SMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + SMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve { + PyObject_HEAD + PyObject *__pyx_v_kwargs; +}; + + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr { + PyObject_HEAD + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *__pyx_outer_scope; + PyObject *__pyx_v_arg; +}; + + + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":245 + * + * # MUMPS HELPERS + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; + + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":274 + * self.array[key - 1] = value + * + * cdef class smumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *, SMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; + + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":313 + * + * # MUMPS CONTEXT + * cdef class BaseMUMPSSolver_INT32_FLOAT32: # <<<<<<<<<<<<<< + * """ + * Base MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, MUMPS_INT *, MUMPS_INT *, SMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, SMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, MUMPS_INT *, MUMPS_INT *, SMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, SMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +static CYTHON_INLINE PyObject* __Pyx_decode_bytes( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string), + start, stop, encoding, errors, decode_func); +} + +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\ + PyObject_RichCompare(op1, op2, Py_EQ) + #endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); + +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +#include + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *); +typedef struct { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject *type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname); +static int __Pyx_Coroutine_clear(PyObject *self); +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue); +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue) +#endif + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +static int __Pyx_patch_abc(void); + +#define __Pyx_Generator_USED +static PyTypeObject *__pyx_GeneratorType = 0; +#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_New(body, closure, name, qualname)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, closure, name, qualname) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(void); + +static int __Pyx_check_binary_version(void); + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self, SMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_get_data_pointers(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, SMUMPS_COMPLEX *__pyx_v_a_val); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mumps_call(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_solve_dense(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, SMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_solve_sparse(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, SMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, SMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython.version' */ + +/* Module declarations from 'cpython.exc' */ + +/* Module declarations from 'cpython.module' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'cpython.tuple' */ + +/* Module declarations from 'cpython.list' */ + +/* Module declarations from 'cpython.sequence' */ + +/* Module declarations from 'cpython.mapping' */ + +/* Module declarations from 'cpython.iterator' */ + +/* Module declarations from 'cpython.number' */ + +/* Module declarations from 'cpython.int' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.bool' */ +static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; + +/* Module declarations from 'cpython.long' */ + +/* Module declarations from 'cpython.float' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.complex' */ +static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; + +/* Module declarations from 'cpython.string' */ + +/* Module declarations from 'cpython.unicode' */ + +/* Module declarations from 'cpython.dict' */ + +/* Module declarations from 'cpython.instance' */ + +/* Module declarations from 'cpython.function' */ + +/* Module declarations from 'cpython.method' */ + +/* Module declarations from 'cpython.weakref' */ + +/* Module declarations from 'cpython.getargs' */ + +/* Module declarations from 'cpython.pythread' */ + +/* Module declarations from 'cpython.pystate' */ + +/* Module declarations from 'cpython.cobject' */ + +/* Module declarations from 'cpython.oldbuffer' */ + +/* Module declarations from 'cpython.set' */ + +/* Module declarations from 'cpython.bytes' */ + +/* Module declarations from 'cpython.pycapsule' */ + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'libc.stdint' */ + +/* Module declarations from 'mumps.src.mumps_INT32_FLOAT32' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr = 0; +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_c_to_fortran_index_array(MUMPS_INT *, MUMPS_INT); /*proto*/ +#define __Pyx_MODULE_NAME "mumps.src.mumps_INT32_FLOAT32" +int __pyx_module_is_main_mumps__src__mumps_INT32_FLOAT32 = 0; + +/* Implementation of 'mumps.src.mumps_INT32_FLOAT32' */ +static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_IndexError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_amd[] = "amd"; +static char __pyx_k_amf[] = "amf"; +static char __pyx_k_doc[] = "__doc__"; +static char __pyx_k_get[] = "get"; +static char __pyx_k_msg[] = "msg"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_rhs[] = "rhs"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_tol[] = "tol"; +static char __pyx_k_args[] = "args"; +static char __pyx_k_auto[] = "auto"; +static char __pyx_k_copy[] = "copy"; +static char __pyx_k_init[] = "__init__"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_ndim[] = "ndim"; +static char __pyx_k_pord[] = "pord"; +static char __pyx_k_qamd[] = "qamd"; +static char __pyx_k_self[] = "self"; +static char __pyx_k_send[] = "send"; +static char __pyx_k_size[] = "size"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_time[] = "time"; +static char __pyx_k_clock[] = "clock"; +static char __pyx_k_close[] = "close"; +static char __pyx_k_dtype[] = "dtype"; +static char __pyx_k_error[] = "error"; +static char __pyx_k_infog[] = "infog"; +static char __pyx_k_metis[] = "metis"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_shape[] = "shape"; +static char __pyx_k_throw[] = "throw"; +static char __pyx_k_zeros[] = "zeros"; +static char __pyx_k_format[] = "format"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_module[] = "__module__"; +static char __pyx_k_nitref[] = "nitref"; +static char __pyx_k_scotch[] = "scotch"; +static char __pyx_k_analyze[] = "analyze"; +static char __pyx_k_float32[] = "float32"; +static char __pyx_k_genexpr[] = "genexpr"; +static char __pyx_k_prepare[] = "__prepare__"; +static char __pyx_k_rhs_val[] = "rhs_val"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ordering[] = "ordering"; +static char __pyx_k_qualname[] = "__qualname__"; +static char __pyx_k_TypeError[] = "TypeError"; +static char __pyx_k_factorize[] = "factorize"; +static char __pyx_k_metaclass[] = "__metaclass__"; +static char __pyx_k_orderings[] = "orderings"; +static char __pyx_k_pivot_tol[] = "pivot_tol"; +static char __pyx_k_IndexError[] = "IndexError"; +static char __pyx_k_MUMPSError[] = "MUMPSError"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_refinement[] = "refinement."; +static char __pyx_k_set_silent[] = "set_silent"; +static char __pyx_k_MUMPS_error[] = "{}. (MUMPS error {})"; +static char __pyx_k_rhs_col_ptr[] = "rhs_col_ptr"; +static char __pyx_k_rhs_row_ind[] = "rhs_row_ind"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_user_defined[] = "user-defined"; +static char __pyx_k_ordering_name[] = "ordering_name"; +static char __pyx_k_asfortranarray[] = "asfortranarray"; +static char __pyx_k_error_messages[] = "error_messages"; +static char __pyx_k_SolveStatistics[] = "SolveStatistics"; +static char __pyx_k_transpose_solve[] = "transpose_solve"; +static char __pyx_k_MUMPSError___init[] = "MUMPSError.__init__"; +static char __pyx_k_Not_enough_memory[] = "Not enough memory"; +static char __pyx_k_AnalysisStatistics[] = "AnalysisStatistics"; +static char __pyx_k_solve_locals_genexpr[] = "solve..genexpr"; +static char __pyx_k_MUMPS_index_must_be_d[] = "MUMPS index must be <= %d"; +static char __pyx_k_mumps_mumps_statistics[] = "mumps.mumps_statistics"; +static char __pyx_k_FactorizationStatistics[] = "FactorizationStatistics"; +static char __pyx_k_MUMPS_failed_with_error[] = "MUMPS failed with error {}."; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_mumps_src_mumps_INT32_FLOAT32[] = "mumps.src.mumps_INT32_FLOAT32"; +static char __pyx_k_Matrix_is_numerically_singular[] = "Matrix is numerically singular"; +static char __pyx_k_This_is_the_base_class_for_the[] = "\nThis is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home)\n\n"; +static char __pyx_k_Matrix_is_singular_in_structure[] = "Matrix is singular in structure"; +static char __pyx_k_The_authors_of_MUMPS_would_like[] = "The authors of MUMPS would like to hear about this"; +static char __pyx_k_Users_syarra_work_VirtualEnvs_n[] = "/Users/syarra/work/VirtualEnvs/nlpy_new/programs/MUMPS.py/mumps/src/mumps_INT32_FLOAT32.pyx"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_MUMPS_index_must_be_1_Fortran_st[] = "MUMPS index must be >= 1 (Fortran style)"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_Not_enough_memory_during_analysi[] = "Not enough memory during analysis phase"; +static char __pyx_k_Only_one_dense_rhs_is_allowed_fo[] = "Only one dense rhs is allowed for performing an iterative"; +static char __pyx_k_Right_hand_side_has_wrong_sizeAt[] = "Right hand side has wrong sizeAttempting to solve the linear system, where A is of size (%d, %d) and rhs is of size (%g)"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_rhs_dense_arrays_must_be_an_NumP[] = "rhs dense arrays must be an NumPy array"; +static char __pyx_k_rhs_not_given_in_the_right_forma[] = "rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_n_s_AnalysisStatistics; +static PyObject *__pyx_n_s_FactorizationStatistics; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_n_s_MUMPSError; +static PyObject *__pyx_n_s_MUMPSError___init; +static PyObject *__pyx_kp_s_MUMPS_error; +static PyObject *__pyx_kp_s_MUMPS_failed_with_error; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_d; +static PyObject *__pyx_kp_s_Matrix_is_numerically_singular; +static PyObject *__pyx_kp_s_Matrix_is_singular_in_structure; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_kp_s_Not_enough_memory; +static PyObject *__pyx_kp_s_Not_enough_memory_during_analysi; +static PyObject *__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo; +static PyObject *__pyx_kp_s_Right_hand_side_has_wrong_sizeAt; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_SolveStatistics; +static PyObject *__pyx_kp_s_The_authors_of_MUMPS_would_like; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Users_syarra_work_VirtualEnvs_n; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_amd; +static PyObject *__pyx_n_s_amf; +static PyObject *__pyx_n_s_analyze; +static PyObject *__pyx_n_s_args; +static PyObject *__pyx_n_s_asfortranarray; +static PyObject *__pyx_n_s_auto; +static PyObject *__pyx_n_s_clock; +static PyObject *__pyx_n_s_close; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_error_messages; +static PyObject *__pyx_n_s_factorize; +static PyObject *__pyx_n_s_float32; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_genexpr; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_infog; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_metis; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_msg; +static PyObject *__pyx_n_s_mumps_mumps_statistics; +static PyObject *__pyx_n_s_mumps_src_mumps_INT32_FLOAT32; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_nitref; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_ordering; +static PyObject *__pyx_n_s_ordering_name; +static PyObject *__pyx_n_s_orderings; +static PyObject *__pyx_n_s_pivot_tol; +static PyObject *__pyx_n_s_pord; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_qamd; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_kp_s_refinement; +static PyObject *__pyx_n_s_rhs; +static PyObject *__pyx_n_s_rhs_col_ptr; +static PyObject *__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP; +static PyObject *__pyx_kp_s_rhs_not_given_in_the_right_forma; +static PyObject *__pyx_n_s_rhs_row_ind; +static PyObject *__pyx_n_s_rhs_val; +static PyObject *__pyx_n_s_scotch; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_n_s_send; +static PyObject *__pyx_n_s_set_silent; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_size; +static PyObject *__pyx_n_s_solve_locals_genexpr; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_throw; +static PyObject *__pyx_n_s_time; +static PyObject *__pyx_n_s_tol; +static PyObject *__pyx_n_s_transpose_solve; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_kp_s_user_defined; +static PyObject *__pyx_n_s_verbose; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32___cinit__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose); /* proto */ +static void __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2__dealloc__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8analyzed___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10factorized___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5icntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4info___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5infog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_14version_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4cntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5rinfo___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rinfog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4set_silent(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6analyze(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_ordering); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8factorize(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5solve_genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10solve(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12refine(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_float_0_01; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_5; +static PyObject *__pyx_int_6; +static PyObject *__pyx_int_7; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_int_neg_5; +static PyObject *__pyx_int_neg_6; +static PyObject *__pyx_int_neg_7; +static PyObject *__pyx_int_neg_8; +static PyObject *__pyx_int_neg_9; +static PyObject *__pyx_int_neg_10; +static PyObject *__pyx_int_neg_11; +static PyObject *__pyx_int_neg_12; +static PyObject *__pyx_int_neg_13; +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_codeobj__14; + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError_1__init__ = {"__init__", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_infog = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_infog,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_infog)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_infog = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError___init__(__pyx_self, __pyx_v_self, __pyx_v_infog); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog) { + PyObject *__pyx_v_msg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":235 + * class MUMPSError(RuntimeError): + * def __init__(self, infog): + * self.error = infog[1] # <<<<<<<<<<<<<< + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_infog, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_error, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":237 + * self.error = infog[1] + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( # <<<<<<<<<<<<<< + * error_messages[self.error], self.error) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":238 + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) # <<<<<<<<<<<<<< + * else: + * msg = "MUMPS failed with error {}.".format(self.error) + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + goto __pyx_L3; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":240 + * error_messages[self.error], self.error) + * else: + * msg = "MUMPS failed with error {}.".format(self.error) # <<<<<<<<<<<<<< + * + * RuntimeError.__init__(self, msg) + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_failed_with_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_6) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":242 + * msg = "MUMPS failed with error {}.".format(self.error) + * + * RuntimeError.__init__(self, msg) # <<<<<<<<<<<<<< + * + * # MUMPS HELPERS + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_builtin_RuntimeError, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_self); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_msg); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":252 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array___cinit__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":260 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":261 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_2__getitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":267 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":269 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.mumps_int_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_4__setitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":272 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * cdef class smumps_real_array: + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.mumps_int_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":281 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array___cinit__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":284 + * pass + * + * cdef get_array(self, SMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self, SMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":289 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":290 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":284 + * pass + * + * cdef get_array(self, SMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_2__getitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":296 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":298 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.smumps_real_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_4__setitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + SMUMPS_REAL __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":301 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_PyFloat_AsFloat(__pyx_v_value); if (unlikely((__pyx_t_1 == (SMUMPS_REAL)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.smumps_real_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_c_to_fortran_index_array(MUMPS_INT *__pyx_v_a, MUMPS_INT __pyx_v_a_size) { + MUMPS_INT __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + MUMPS_INT __pyx_t_2; + __Pyx_RefNannySetupContext("c_to_fortran_index_array", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":309 + * MUMPS_INT i + * + * for i from 0 <= i < a_size: # <<<<<<<<<<<<<< + * a[i] += 1 + * + */ + __pyx_t_1 = __pyx_v_a_size; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":310 + * + * for i from 0 <= i < a_size: + * a[i] += 1 # <<<<<<<<<<<<<< + * + * # MUMPS CONTEXT + */ + __pyx_t_2 = __pyx_v_i; + (__pyx_v_a[__pyx_t_2]) = ((__pyx_v_a[__pyx_t_2]) + 1); + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + MUMPS_INT __pyx_v_n; + MUMPS_INT __pyx_v_nnz; + PyObject *__pyx_v_comm_fortran = 0; + PyObject *__pyx_v_sym = 0; + PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":324 + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32___cinit__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32___cinit__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":333 + * verbose: a boolean to turn on or off the verbosity of MUMPS + * """ + * self.nrow = n # <<<<<<<<<<<<<< + * self.ncol = n + * self.nnz = nnz + */ + __pyx_v_self->nrow = __pyx_v_n; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":334 + * """ + * self.nrow = n + * self.ncol = n # <<<<<<<<<<<<<< + * self.nnz = nnz + * + */ + __pyx_v_self->ncol = __pyx_v_n; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":335 + * self.nrow = n + * self.ncol = n + * self.nnz = nnz # <<<<<<<<<<<<<< + * + * assert self.ncol == self.nrow + */ + __pyx_v_self->nnz = __pyx_v_nnz; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":337 + * self.nnz = nnz + * + * assert self.ncol == self.nrow # <<<<<<<<<<<<<< + * + * self.initialize_mumps_struct(comm_fortran, sym) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_self->ncol == __pyx_v_self->nrow) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":339 + * assert self.ncol == self.nrow + * + * self.initialize_mumps_struct(comm_fortran, sym) # <<<<<<<<<<<<<< + * + * # `initialize_mumps_struct` **must** be called before assigning + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->initialize_mumps_struct(__pyx_v_self, __pyx_v_comm_fortran, __pyx_v_sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":343 + * # `initialize_mumps_struct` **must** be called before assigning + * # a value to n (size of the matrix) + * self.params.n = self.nrow # <<<<<<<<<<<<<< + * + * self.analyzed = False + */ + __pyx_v_self->params.n = ((MUMPS_INT)__pyx_v_self->nrow); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":345 + * self.params.n = self.nrow + * + * self.analyzed = False # <<<<<<<<<<<<<< + * self.factorized = False + * self.out_of_core = False + */ + __pyx_v_self->analyzed = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":346 + * + * self.analyzed = False + * self.factorized = False # <<<<<<<<<<<<<< + * self.out_of_core = False + * + */ + __pyx_v_self->factorized = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":347 + * self.analyzed = False + * self.factorized = False + * self.out_of_core = False # <<<<<<<<<<<<<< + * + * if not verbose: + */ + __pyx_v_self->out_of_core = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = ((!__pyx_t_2) != 0); + if (__pyx_t_3) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":350 + * + * if not verbose: + * self.set_silent() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_silent); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("initialize_mumps_struct", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":362 + * sym: a boolean indicating if A is a symmetric matrix or not + * """ + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.params.sym = sym + * self.params.par = 1 + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":363 + * """ + * self.params.job = -1 + * self.params.sym = sym # <<<<<<<<<<<<<< + * self.params.par = 1 + * + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_sym); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":364 + * self.params.job = -1 + * self.params.sym = sym + * self.params.par = 1 # <<<<<<<<<<<<<< + * + * self.params.comm_fortran = comm_fortran + */ + __pyx_v_self->params.par = 1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":366 + * self.params.par = 1 + * + * self.params.comm_fortran = comm_fortran # <<<<<<<<<<<<<< + * + * self.mumps_call() + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_comm_fortran); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":368 + * self.params.comm_fortran = comm_fortran + * + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # integer control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":371 + * + * # integer control parameters + * self.icntl = mumps_int_array() # <<<<<<<<<<<<<< + * self.icntl.get_array(self.params.icntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 371; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->icntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_v_self->icntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":372 + * # integer control parameters + * self.icntl = mumps_int_array() + * self.icntl.get_array(self.params.icntl) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_v_self->icntl->__pyx_vtab)->get_array(__pyx_v_self->icntl, __pyx_v_self->params.icntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":375 + * + * # integer information parameters + * self.info = mumps_int_array() # <<<<<<<<<<<<<< + * self.info.get_array(self.params.info) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->info); + __Pyx_DECREF(((PyObject *)__pyx_v_self->info)); + __pyx_v_self->info = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":376 + * # integer information parameters + * self.info = mumps_int_array() + * self.info.get_array(self.params.info) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_v_self->info->__pyx_vtab)->get_array(__pyx_v_self->info, __pyx_v_self->params.info, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":379 + * + * # integer information parameters + * self.infog = mumps_int_array() # <<<<<<<<<<<<<< + * self.infog.get_array(self.params.infog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->infog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->infog)); + __pyx_v_self->infog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":380 + * # integer information parameters + * self.infog = mumps_int_array() + * self.infog.get_array(self.params.infog) # <<<<<<<<<<<<<< + * + * # real/complex control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)__pyx_v_self->infog->__pyx_vtab)->get_array(__pyx_v_self->infog, __pyx_v_self->params.infog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":383 + * + * # real/complex control parameters + * self.cntl = smumps_real_array() # <<<<<<<<<<<<<< + * self.cntl.get_array(self.params.cntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->cntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_v_self->cntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":384 + * # real/complex control parameters + * self.cntl = smumps_real_array() + * self.cntl.get_array(self.params.cntl) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_v_self->cntl->__pyx_vtab)->get_array(__pyx_v_self->cntl, __pyx_v_self->params.cntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 384; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":387 + * + * # real/complex information parameters + * self.rinfo = smumps_real_array() # <<<<<<<<<<<<<< + * self.rinfo.get_array(self.params.rinfo) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfo); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_v_self->rinfo = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":388 + * # real/complex information parameters + * self.rinfo = smumps_real_array() + * self.rinfo.get_array(self.params.rinfo) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_v_self->rinfo->__pyx_vtab)->get_array(__pyx_v_self->rinfo, __pyx_v_self->params.rinfo, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":391 + * + * # real/complex information parameters + * self.rinfog = smumps_real_array() # <<<<<<<<<<<<<< + * self.rinfog.get_array(self.params.rinfog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_v_self->rinfog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":392 + * # real/complex information parameters + * self.rinfog = smumps_real_array() + * self.rinfog.get_array(self.params.rinfog) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)__pyx_v_self->rinfog->__pyx_vtab)->get_array(__pyx_v_self->rinfog, __pyx_v_self->params.rinfog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.initialize_mumps_struct", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_get_data_pointers(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, SMUMPS_COMPLEX *__pyx_v_a_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_data_pointers", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":410 + * """ + * + * self.a_row = a_row # <<<<<<<<<<<<<< + * self.a_col = a_col + * self.a_val = a_val + */ + __pyx_v_self->a_row = ((MUMPS_INT *)__pyx_v_a_row); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":411 + * + * self.a_row = a_row + * self.a_col = a_col # <<<<<<<<<<<<<< + * self.a_val = a_val + * + */ + __pyx_v_self->a_col = ((MUMPS_INT *)__pyx_v_a_col); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":412 + * self.a_row = a_row + * self.a_col = a_col + * self.a_val = a_val # <<<<<<<<<<<<<< + * + * # transform c index arrays to fortran arrays + */ + __pyx_v_self->a_val = ((SMUMPS_COMPLEX *)__pyx_v_a_val); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":415 + * + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) # <<<<<<<<<<<<<< + * c_to_fortran_index_array(self.a_col, self.nnz) + * + */ + __pyx_t_1 = __pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_c_to_fortran_index_array(__pyx_v_self->a_row, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":416 + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) + * c_to_fortran_index_array(self.a_col, self.nnz) # <<<<<<<<<<<<<< + * + * self.set_centralized_assembled_matrix() + */ + __pyx_t_1 = __pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_c_to_fortran_index_array(__pyx_v_self->a_col, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":418 + * c_to_fortran_index_array(self.a_col, self.nnz) + * + * self.set_centralized_assembled_matrix() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->set_centralized_assembled_matrix(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.get_data_pointers", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_centralized_assembled_matrix", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":427 + * """ + * + * self.params.nz = self.nnz # <<<<<<<<<<<<<< + * + * self.params.irn = self.a_row + */ + __pyx_v_self->params.nz = ((MUMPS_INT)__pyx_v_self->nnz); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":429 + * self.params.nz = self.nnz + * + * self.params.irn = self.a_row # <<<<<<<<<<<<<< + * self.params.jcn = self.a_col + * self.params.a = self.a_val + */ + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_self->a_row); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":430 + * + * self.params.irn = self.a_row + * self.params.jcn = self.a_col # <<<<<<<<<<<<<< + * self.params.a = self.a_val + * + */ + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_self->a_col); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":431 + * self.params.irn = self.a_row + * self.params.jcn = self.a_col + * self.params.a = self.a_val # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_self->params.a = ((SMUMPS_COMPLEX *)__pyx_v_self->a_val); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + +/* Python wrapper */ +static void __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2__dealloc__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2__dealloc__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":436 + * def __dealloc__(self): + * # autodestruct mumps internal + * self.params.job = -2 # <<<<<<<<<<<<<< + * self.mumps_call() + * self.params.job = -1 + */ + __pyx_v_self->params.job = -2; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":437 + * # autodestruct mumps internal + * self.params.job = -2 + * self.mumps_call() # <<<<<<<<<<<<<< + * self.params.job = -1 + * self.mumps_call() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":438 + * self.params.job = -2 + * self.mumps_call() + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":439 + * self.mumps_call() + * self.params.job = -1 + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # Properties + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_WriteUnraisable("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":444 + * # COMMON Properties + * property analyzed: + * def __get__(self): return self.analyzed # <<<<<<<<<<<<<< + * property factorized: + * def __get__(self): return self.factorized + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8analyzed_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8analyzed_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8analyzed___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8analyzed___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->analyzed); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.analyzed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":446 + * def __get__(self): return self.analyzed + * property factorized: + * def __get__(self): return self.factorized # <<<<<<<<<<<<<< + * property sym: + * def __get__(self): return self.params.sym + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10factorized_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10factorized_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10factorized___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10factorized___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->factorized); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.factorized.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":448 + * def __get__(self): return self.factorized + * property sym: + * def __get__(self): return self.params.sym # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.sym = value + * property par: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.sym.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":449 + * property sym: + * def __get__(self): return self.params.sym + * def __set__(self, value): self.params.sym = value # <<<<<<<<<<<<<< + * property par: + * def __get__(self): return self.params.par + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.sym.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":451 + * def __set__(self, value): self.params.sym = value + * property par: + * def __get__(self): return self.params.par # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.par = value + * property job: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.par); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.par.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":452 + * property par: + * def __get__(self): return self.params.par + * def __set__(self, value): self.params.par = value # <<<<<<<<<<<<<< + * property job: + * def __get__(self): return self.params.job + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 452; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.par = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.par.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":454 + * def __set__(self, value): self.params.par = value + * property job: + * def __get__(self): return self.params.job # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.job = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.job); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.job.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":455 + * property job: + * def __get__(self): return self.params.job + * def __set__(self, value): self.params.job = value # <<<<<<<<<<<<<< + * + * property comm_fortran: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.job = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.job.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":458 + * + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.comm_fortran = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.comm_fortran); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 458; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.comm_fortran.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":459 + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran + * def __set__(self, value): self.params.comm_fortran = value # <<<<<<<<<<<<<< + * + * property icntl: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 459; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.comm_fortran.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5icntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5icntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5icntl___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5icntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":463 + * property icntl: + * def __get__(self): + * return self.icntl # <<<<<<<<<<<<<< + * + * property n: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_r = ((PyObject *)__pyx_v_self->icntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":466 + * + * property n: + * def __get__(self): return self.params.n # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.n = value + * property nz_alloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.n); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.n.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":467 + * property n: + * def __get__(self): return self.params.n + * def __set__(self, value): self.params.n = value # <<<<<<<<<<<<<< + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.n = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.n.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":469 + * def __set__(self, value): self.params.n = value + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_alloc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_alloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 469; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz_alloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":470 + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + * def __set__(self, value): self.params.nz_alloc = value # <<<<<<<<<<<<<< + * + * property nz: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 470; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_alloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz_alloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":473 + * + * property nz: + * def __get__(self): return self.params.nz # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz = value + * property irn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 473; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":474 + * property nz: + * def __get__(self): return self.params.nz + * def __set__(self, value): self.params.nz = value # <<<<<<<<<<<<<< + * property irn: + * def __get__(self): return self.params.irn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":476 + * def __set__(self, value): self.params.nz = value + * property irn: + * def __get__(self): return self.params.irn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn = value + * property jcn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":477 + * property irn: + * def __get__(self): return self.params.irn + * def __set__(self, long value): self.params.irn = value # <<<<<<<<<<<<<< + * property jcn: + * def __get__(self): return self.params.jcn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":479 + * def __set__(self, long value): self.params.irn = value + * property jcn: + * def __get__(self): return self.params.jcn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.jcn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":480 + * property jcn: + * def __get__(self): return self.params.jcn + * def __set__(self, long value): self.params.jcn = value # <<<<<<<<<<<<<< + * + * property nz_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.jcn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":483 + * + * property nz_loc: + * def __get__(self): return self.params.nz_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":484 + * property nz_loc: + * def __get__(self): return self.params.nz_loc + * def __set__(self, value): self.params.nz_loc = value # <<<<<<<<<<<<<< + * property irn_loc: + * def __get__(self): return self.params.irn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":486 + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + * def __get__(self): return self.params.irn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":487 + * property irn_loc: + * def __get__(self): return self.params.irn_loc + * def __set__(self, long value): self.params.irn_loc = value # <<<<<<<<<<<<<< + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":489 + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.jcn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":490 + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + * def __set__(self, long value): self.params.jcn_loc = value # <<<<<<<<<<<<<< + * + * property nelt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 490; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.jcn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":493 + * + * property nelt: + * def __get__(self): return self.params.nelt # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nelt = value + * property eltptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nelt); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 493; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nelt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":494 + * property nelt: + * def __get__(self): return self.params.nelt + * def __set__(self, value): self.params.nelt = value # <<<<<<<<<<<<<< + * property eltptr: + * def __get__(self): return self.params.eltptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 494; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nelt = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nelt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":496 + * def __set__(self, value): self.params.nelt = value + * property eltptr: + * def __get__(self): return self.params.eltptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 496; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.eltptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":497 + * property eltptr: + * def __get__(self): return self.params.eltptr + * def __set__(self, long value): self.params.eltptr = value # <<<<<<<<<<<<<< + * property eltvar: + * def __get__(self): return self.params.eltvar + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 497; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.eltptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":499 + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + * def __get__(self): return self.params.eltvar # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltvar = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltvar)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.eltvar.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":500 + * property eltvar: + * def __get__(self): return self.params.eltvar + * def __set__(self, long value): self.params.eltvar = value # <<<<<<<<<<<<<< + * + * property perm_in: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.eltvar.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltvar = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":503 + * + * property perm_in: + * def __get__(self): return self.params.perm_in # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.perm_in = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.perm_in)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 503; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.perm_in.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":504 + * property perm_in: + * def __get__(self): return self.params.perm_in + * def __set__(self, long value): self.params.perm_in = value # <<<<<<<<<<<<<< + * + * property sym_perm: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.perm_in.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.perm_in = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":507 + * + * property sym_perm: + * def __get__(self): return self.params.sym_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sym_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.sym_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":508 + * property sym_perm: + * def __get__(self): return self.params.sym_perm + * def __set__(self, long value): self.params.sym_perm = value # <<<<<<<<<<<<<< + * property uns_perm: + * def __get__(self): return self.params.uns_perm + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 508; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.sym_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sym_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":510 + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + * def __get__(self): return self.params.uns_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.uns_perm = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.uns_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.uns_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":511 + * property uns_perm: + * def __get__(self): return self.params.uns_perm + * def __set__(self, long value): self.params.uns_perm = value # <<<<<<<<<<<<<< + * + * property irhs_sparse: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.uns_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.uns_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":514 + * + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 514; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":515 + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse + * def __set__(self, long value): self.params.irhs_sparse = value # <<<<<<<<<<<<<< + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 515; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":517 + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_ptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 517; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irhs_ptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":518 + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + * def __set__(self, long value): self.params.irhs_ptr = value # <<<<<<<<<<<<<< + * property isol_loc: + * def __get__(self): return self.params.isol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.irhs_ptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":520 + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + * def __get__(self): return self.params.isol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.isol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.isol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 520; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.isol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":521 + * property isol_loc: + * def __get__(self): return self.params.isol_loc + * def __set__(self, long value): self.params.isol_loc = value # <<<<<<<<<<<<<< + * + * property nrhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 521; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.isol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.isol_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":524 + * + * property nrhs: + * def __get__(self): return self.params.nrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":525 + * property nrhs: + * def __get__(self): return self.params.nrhs + * def __set__(self, value): self.params.nrhs = value # <<<<<<<<<<<<<< + * property lrhs: + * def __get__(self): return self.params.lrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":527 + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + * def __get__(self): return self.params.lrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":528 + * property lrhs: + * def __get__(self): return self.params.lrhs + * def __set__(self, value): self.params.lrhs = value # <<<<<<<<<<<<<< + * property lredrhs: + * def __get__(self): return self.params.lredrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":530 + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + * def __get__(self): return self.params.lredrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lredrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 530; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lredrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":531 + * property lredrhs: + * def __get__(self): return self.params.lredrhs + * def __set__(self, value): self.params.lredrhs = value # <<<<<<<<<<<<<< + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 531; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lredrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lredrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":533 + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_rhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 533; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz_rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":534 + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + * def __set__(self, value): self.params.nz_rhs = value # <<<<<<<<<<<<<< + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 534; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_rhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nz_rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":536 + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lsol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lsol_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lsol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":537 + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + * def __set__(self, value): self.params.lsol_loc = value # <<<<<<<<<<<<<< + * + * property schur_mloc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lsol_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lsol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":540 + * + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_mloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur_mloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":541 + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc + * def __set__(self, value): self.params.schur_mloc = value # <<<<<<<<<<<<<< + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 541; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_mloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur_mloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":543 + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_nloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 543; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur_nloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":544 + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + * def __set__(self, value): self.params.schur_nloc = value # <<<<<<<<<<<<<< + * property schur_lld: + * def __get__(self): return self.params.schur_lld + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_nloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur_nloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":546 + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + * def __get__(self): return self.params.schur_lld # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_lld = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_lld); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 546; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur_lld.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":547 + * property schur_lld: + * def __get__(self): return self.params.schur_lld + * def __set__(self, value): self.params.schur_lld = value # <<<<<<<<<<<<<< + * + * property mblock: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_lld = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur_lld.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":550 + * + * property mblock: + * def __get__(self): return self.params.mblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.mblock = value + * property nblock: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.mblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 550; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.mblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":551 + * property mblock: + * def __get__(self): return self.params.mblock + * def __set__(self, value): self.params.mblock = value # <<<<<<<<<<<<<< + * property nblock: + * def __get__(self): return self.params.nblock + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 551; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.mblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.mblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":553 + * def __set__(self, value): self.params.mblock = value + * property nblock: + * def __get__(self): return self.params.nblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nblock = value + * property nprow: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":554 + * property nblock: + * def __get__(self): return self.params.nblock + * def __set__(self, value): self.params.nblock = value # <<<<<<<<<<<<<< + * property nprow: + * def __get__(self): return self.params.nprow + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 554; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":556 + * def __set__(self, value): self.params.nblock = value + * property nprow: + * def __get__(self): return self.params.nprow # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nprow = value + * property npcol: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nprow); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nprow.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":557 + * property nprow: + * def __get__(self): return self.params.nprow + * def __set__(self, value): self.params.nprow = value # <<<<<<<<<<<<<< + * property npcol: + * def __get__(self): return self.params.npcol + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nprow = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.nprow.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":559 + * def __set__(self, value): self.params.nprow = value + * property npcol: + * def __get__(self): return self.params.npcol # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.npcol = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.npcol); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.npcol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":560 + * property npcol: + * def __get__(self): return self.params.npcol + * def __set__(self, value): self.params.npcol = value # <<<<<<<<<<<<<< + * + * property info: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.npcol = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.npcol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4info_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4info_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4info___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4info___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":564 + * property info: + * def __get__(self): + * return self.info # <<<<<<<<<<<<<< + * + * property infog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->info)); + __pyx_r = ((PyObject *)__pyx_v_self->info); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5infog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5infog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5infog___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5infog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":568 + * property infog: + * def __get__(self): + * return self.infog # <<<<<<<<<<<<<< + * + * property deficiency: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __pyx_r = ((PyObject *)__pyx_v_self->infog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":571 + * + * property deficiency: + * def __get__(self): return self.params.deficiency # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.deficiency); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.deficiency.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":572 + * property deficiency: + * def __get__(self): return self.params.deficiency + * def __set__(self, value): self.params.deficiency = value # <<<<<<<<<<<<<< + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.deficiency = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.deficiency.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":574 + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.pivnul_list)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 574; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.pivnul_list.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":575 + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + * def __set__(self, long value): self.params.pivnul_list = value # <<<<<<<<<<<<<< + * property mapping: + * def __get__(self): return self.params.mapping + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 575; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.pivnul_list.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.pivnul_list = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":577 + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + * def __get__(self): return self.params.mapping # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.mapping = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.mapping)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.mapping.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":578 + * property mapping: + * def __get__(self): return self.params.mapping + * def __set__(self, long value): self.params.mapping = value # <<<<<<<<<<<<<< + * + * property size_schur: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 578; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.mapping.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.mapping = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":581 + * + * property size_schur: + * def __get__(self): return self.params.size_schur # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.size_schur); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 581; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.size_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":582 + * property size_schur: + * def __get__(self): return self.params.size_schur + * def __set__(self, value): self.params.size_schur = value # <<<<<<<<<<<<<< + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 582; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.size_schur = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.size_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":584 + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.listvar_schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.listvar_schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 584; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.listvar_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":585 + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + * def __set__(self, long value): self.params.listvar_schur = value # <<<<<<<<<<<<<< + * + * property instance_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.listvar_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.listvar_schur = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":588 + * + * property instance_number: + * def __get__(self): return self.params.instance_number # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.instance_number = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.instance_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.instance_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":589 + * property instance_number: + * def __get__(self): return self.params.instance_number + * def __set__(self, value): self.params.instance_number = value # <<<<<<<<<<<<<< + * + * property version_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 589; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.instance_number = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.instance_number.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_14version_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_14version_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_14version_number___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_14version_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":593 + * property version_number: + * def __get__(self): + * return ( self.params.version_number).decode('ascii') # <<<<<<<<<<<<<< + * + * property ooc_tmpdir: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.version_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.version_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":597 + * property ooc_tmpdir: + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_tmpdir); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.ooc_tmpdir.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 598; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.ooc_tmpdir.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":599 + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) # <<<<<<<<<<<<<< + * property ooc_prefix: + * def __get__(self): + */ + strncpy(__pyx_v_self->params.ooc_tmpdir, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_tmpdir))); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":602 + * property ooc_prefix: + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_prefix); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.ooc_prefix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 603; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.ooc_prefix.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":604 + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) # <<<<<<<<<<<<<< + * + * property write_problem: + */ + strncpy(__pyx_v_self->params.ooc_prefix, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_prefix))); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":608 + * property write_problem: + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.write_problem); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.write_problem.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.write_problem.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":610 + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) # <<<<<<<<<<<<<< + * + * property lwk_user: + */ + strncpy(__pyx_v_self->params.write_problem, __pyx_v_value, (sizeof(__pyx_v_self->params.write_problem))); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":613 + * + * property lwk_user: + * def __get__(self): return self.params.lwk_user # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lwk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lwk_user); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lwk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":614 + * property lwk_user: + * def __get__(self): return self.params.lwk_user + * def __set__(self, value): self.params.lwk_user = value # <<<<<<<<<<<<<< + * + * # TYPED Properties + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lwk_user = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.lwk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4cntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4cntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4cntl___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4cntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":619 + * property cntl: + * def __get__(self): + * return self.cntl # <<<<<<<<<<<<<< + * + * property a: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_r = ((PyObject *)__pyx_v_self->cntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":622 + * + * property a: + * def __get__(self): return self.params.a # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.a.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":623 + * property a: + * def __get__(self): return self.params.a + * def __set__(self, long value): self.params.a = value # <<<<<<<<<<<<<< + * + * property a_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.a.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":626 + * + * property a_loc: + * def __get__(self): return self.params.a_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 626; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.a_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":627 + * property a_loc: + * def __get__(self): return self.params.a_loc + * def __set__(self, long value): self.params.a_loc = value # <<<<<<<<<<<<<< + * + * property a_elt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 627; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.a_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_loc = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":630 + * + * property a_elt: + * def __get__(self): return self.params.a_elt # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_elt = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_elt)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 630; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.a_elt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":631 + * property a_elt: + * def __get__(self): return self.params.a_elt + * def __set__(self, long value): self.params.a_elt = value # <<<<<<<<<<<<<< + * + * property colsca: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.a_elt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_elt = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":634 + * + * property colsca: + * def __get__(self): return self.params.colsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.colsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.colsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":635 + * property colsca: + * def __get__(self): return self.params.colsca + * def __set__(self, long value): self.params.colsca = value # <<<<<<<<<<<<<< + * property rowsca: + * def __get__(self): return self.params.rowsca + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.colsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.colsca = ((SMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":637 + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + * def __get__(self): return self.params.rowsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rowsca = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rowsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.rowsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":638 + * property rowsca: + * def __get__(self): return self.params.rowsca + * def __set__(self, long value): self.params.rowsca = value # <<<<<<<<<<<<<< + * + * property rhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.rowsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rowsca = ((SMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":641 + * + * property rhs: + * def __get__(self): return self.params.rhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 641; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":642 + * property rhs: + * def __get__(self): return self.params.rhs + * def __set__(self, long value): self.params.rhs = value # <<<<<<<<<<<<<< + * property redrhs: + * def __get__(self): return self.params.redrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":644 + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + * def __get__(self): return self.params.redrhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.redrhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.redrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":645 + * property redrhs: + * def __get__(self): return self.params.redrhs + * def __set__(self, long value): self.params.redrhs = value # <<<<<<<<<<<<<< + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 645; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.redrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.redrhs = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":647 + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.rhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":648 + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + * def __set__(self, long value): self.params.rhs_sparse = value # <<<<<<<<<<<<<< + * property sol_loc: + * def __get__(self): return self.params.sol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.rhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs_sparse = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":650 + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + * def __get__(self): return self.params.sol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.sol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":651 + * property sol_loc: + * def __get__(self): return self.params.sol_loc + * def __set__(self, long value): self.params.sol_loc = value # <<<<<<<<<<<<<< + * + * property rinfo: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.sol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sol_loc = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5rinfo_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5rinfo_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5rinfo___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5rinfo___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":655 + * property rinfo: + * def __get__(self): + * return self.rinfo # <<<<<<<<<<<<<< + * + * property rinfog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfo); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rinfog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rinfog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rinfog___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rinfog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":659 + * property rinfog: + * def __get__(self): + * return self.rinfog # <<<<<<<<<<<<<< + * + * property schur: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":662 + * + * property schur: + * def __get__(self): return self.params.schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":663 + * property schur: + * def __get__(self): return self.params.schur + * def __set__(self, long value): self.params.schur = value # <<<<<<<<<<<<<< + * + * property wk_user: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.schur = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":666 + * + * property wk_user: + * def __get__(self): return self.params.wk_user # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.wk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.wk_user)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.wk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":667 + * property wk_user: + * def __get__(self): return self.params.wk_user + * def __set__(self, long value): self.params.wk_user = value # <<<<<<<<<<<<<< + * + * # MUMPS CALL + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 667; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.wk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.wk_user = ((SMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mumps_call(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mumps_call", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":674 + * Call to Xmumps_c(XMUMPS_STRUC_C). + * """ + * smumps_c(&self.params) # <<<<<<<<<<<<<< + * + * + */ + smumps_c((&__pyx_v_self->params)); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4set_silent[] = "\n Silence **all* MUMPS output.\n\n See MUMPS documentation.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_silent (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4set_silent(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4set_silent(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_silent", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":683 + * See MUMPS documentation. + * """ + * self.icntl[1] = 0 # <<<<<<<<<<<<<< + * self.icntl[2] = 0 + * self.icntl[3] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 1, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":684 + * """ + * self.icntl[1] = 0 + * self.icntl[2] = 0 # <<<<<<<<<<<<<< + * self.icntl[3] = 0 + * self.icntl[4] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":685 + * self.icntl[1] = 0 + * self.icntl[2] = 0 + * self.icntl[3] = 0 # <<<<<<<<<<<<<< + * self.icntl[4] = 0 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 3, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":686 + * self.icntl[2] = 0 + * self.icntl[3] = 0 + * self.icntl[4] = 0 # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 4, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.set_silent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6analyze[] = "\n Performs analysis step of MUMPS.\n\n In the analyis step, MUMPS is able to figure out a reordering for the \n given matrix. It does so if `ordering` is set to 'auto'.\n If not MUMPS will use the provided ordering.\n MUMPS statistics for the analysis are available in `analysis_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("analyze (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "analyze") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("analyze", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6analyze(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), __pyx_v_ordering); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6analyze(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_ordering) { + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("analyze", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_1 = (__pyx_v_self->analyzed != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":705 + * """ + * if self.analyzed: + * return # <<<<<<<<<<<<<< + * + * self.icntl[7] = orderings[ordering] + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":707 + * return + * + * self.icntl[7] = orderings[ordering] # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.params.job = 1 # analyse + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_orderings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_ordering); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 7, __pyx_t_3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":708 + * + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.params.job = 1 # analyse + * self.mumps_call() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_t1 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":709 + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() + * self.params.job = 1 # analyse # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_v_self->params.job = 1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":710 + * t1 = time.clock() + * self.params.job = 1 # analyse + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":711 + * self.params.job = 1 # analyse + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * if self.infog[1] < 0: + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_t2 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":714 + * + * if self.infog[1] < 0: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * + * self.analyzed = True + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":716 + * raise MUMPSError(self.infog) + * + * self.analyzed = True # <<<<<<<<<<<<<< + * + * # self.analysis_stats = AnalysisStatistics(self.params, + */ + __pyx_v_self->analyzed = 1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8factorize[] = "\n Perform the LU factorization of the matrix (or LDL' if the matrix\n is symmetric).\n\n This factorization can then later be used to solve a linear system\n with `solve`. Statistical data of the factorization is stored in\n `factor_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n pivot_tol: number in the range [0, 1]\n pivoting threshold. Pivoting is typically limited in sparse\n solvers, as too much pivoting destroys sparsity. 1.0 means full\n pivoting, whereas 0.0 means no pivoting. Default is 0.01.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + PyObject *__pyx_v_pivot_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("factorize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,&__pyx_n_s_pivot_tol,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + values[1] = ((PyObject *)__pyx_float_0_01); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pivot_tol); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "factorize") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + __pyx_v_pivot_tol = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("factorize", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8factorize(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), __pyx_v_ordering, __pyx_v_pivot_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8factorize(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol) { + int __pyx_v_done; + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("factorize", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + __pyx_t_1 = ((!(__pyx_v_self->analyzed != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":744 + * # Analysis phase must be done before factorization + * if not self.analyzed : + * self.analyze(ordering=ordering) # <<<<<<<<<<<<<< + * + * self.icntl[22] = 1 if self.out_of_core else 1 + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_analyze); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_ordering, __pyx_v_ordering) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":746 + * self.analyze(ordering=ordering) + * + * self.icntl[22] = 1 if self.out_of_core else 1 # <<<<<<<<<<<<<< + * self.cntl[1] = pivot_tol + * self.params.job = 2 + */ + if ((__pyx_v_self->out_of_core != 0)) { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 22, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":747 + * + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol # <<<<<<<<<<<<<< + * self.params.job = 2 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 1, __pyx_v_pivot_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":748 + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol + * self.params.job = 2 # <<<<<<<<<<<<<< + * + * done = False + */ + __pyx_v_self->params.job = 2; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":750 + * self.params.job = 2 + * + * done = False # <<<<<<<<<<<<<< + * while not done: + * t1 = time.clock() + */ + __pyx_v_done = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":751 + * + * done = False + * while not done: # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.mumps_call() + */ + while (1) { + __pyx_t_1 = ((!(__pyx_v_done != 0)) != 0); + if (!__pyx_t_1) break; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":752 + * done = False + * while not done: + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_t1, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":753 + * while not done: + * t1 = time.clock() + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":754 + * t1 = time.clock() + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * # error -8, -9 (not enough allocated memory) is treated + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_t2, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + __pyx_t_4 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_8, -8L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_5) { + } else { + __pyx_t_1 = __pyx_t_5; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_9, -9L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_L8_bool_binop_done:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":761 + * if self.infog[1] in (-8, -9): + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 # <<<<<<<<<<<<<< + * else: + * raise MUMPSError(self.infog) + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->icntl), 14, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_int_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 14, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":763 + * self.icntl[14] = self.icntl[14]*2 + * else: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * else: + * done = True + */ + /*else*/ { + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":765 + * raise MUMPSError(self.infog) + * else: + * done = True # <<<<<<<<<<<<<< + * + * self.factorized = True + */ + /*else*/ { + __pyx_v_done = 1; + } + __pyx_L6:; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":767 + * done = True + * + * self.factorized = True # <<<<<<<<<<<<<< + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + */ + __pyx_v_self->factorized = 1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, SMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_solve_dense(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, SMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_dense", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":782 + * MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + * """ + * self.params.nrhs = nrhs # <<<<<<<<<<<<<< + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + */ + __pyx_v_self->params.nrhs = ((MUMPS_INT)__pyx_v_nrhs); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":783 + * """ + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length # <<<<<<<<<<<<<< + * self.params.rhs = rhs + * self.params.job = 3 # solve + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_rhs_length); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":784 + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length + * self.params.rhs = rhs # <<<<<<<<<<<<<< + * self.params.job = 3 # solve + * self.mumps_call() + */ + __pyx_v_self->params.rhs = ((SMUMPS_COMPLEX *)__pyx_v_rhs); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":785 + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":786 + * self.params.rhs = rhs + * self.params.job = 3 # solve + * self.mumps_call() # <<<<<<<<<<<<<< + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, SMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.solve_dense", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * SMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * SMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_solve_sparse(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, SMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, SMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_sparse", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":807 + * + * """ + * self.params.nz_rhs = rhs_nnz # <<<<<<<<<<<<<< + * self.params.nrhs = nrhs # nrhs -1 ? + * + */ + __pyx_v_self->params.nz_rhs = __pyx_v_rhs_nnz; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":808 + * """ + * self.params.nz_rhs = rhs_nnz + * self.params.nrhs = nrhs # nrhs -1 ? # <<<<<<<<<<<<<< + * + * self.params.rhs_sparse = rhs_val + */ + __pyx_v_self->params.nrhs = __pyx_v_nrhs; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":810 + * self.params.nrhs = nrhs # nrhs -1 ? + * + * self.params.rhs_sparse = rhs_val # <<<<<<<<<<<<<< + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr + */ + __pyx_v_self->params.rhs_sparse = ((SMUMPS_COMPLEX *)__pyx_v_rhs_val); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":811 + * + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind # <<<<<<<<<<<<<< + * self.params.irhs_ptr = rhs_col_ptr + * + */ + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_rhs_row_ind); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":812 + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr # <<<<<<<<<<<<<< + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + */ + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_rhs_col_ptr); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":815 + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length # <<<<<<<<<<<<<< + * self.params.rhs = x + * + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_x_length); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":816 + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length + * self.params.rhs = x # <<<<<<<<<<<<<< + * + * self.params.job = 3 # solve + */ + __pyx_v_self->params.rhs = ((SMUMPS_COMPLEX *)__pyx_v_x); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":818 + * self.params.rhs = x + * + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":819 + * + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 20, __pyx_int_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":820 + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() # <<<<<<<<<<<<<< + * + * def solve(self, **kwargs): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * SMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * SMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.solve_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10solve[] = "\n\n Args:\n rhs: dense NumPy array (matrix or vector).\n rhs_col_ptr, rhs_row_ind, rhs_val: sparse NumPy CSC arrays (matrix or vector).\n transpose_solve : ``True`` or ``False`` whether to solve A * x = rhs or A^T * x = rhs. Default is ``False``\n\n Returns:\n Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_kwargs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solve (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;} + if (__pyx_kwds && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 1))) return NULL; + __pyx_v_kwargs = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10solve(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), __pyx_v_kwargs); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5solve_genexpr(PyObject *__pyx_self) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *)__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5solve_2generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_solve_locals_genexpr); if (unlikely(!gen)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.solve.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __pyx_tuple__3; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= 3) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_arg); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_arg, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs)) { __Pyx_RaiseClosureNameError("kwargs"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } + if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_cur_scope->__pyx_v_arg, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (__pyx_t_5) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + } + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10solve(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_kwargs) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *__pyx_cur_scope; + PyObject *__pyx_v_transpose_solve = NULL; + MUMPS_INT __pyx_v_nrhs; + PyObject *__pyx_v_rhs = NULL; + PyObject *__pyx_v_rhs_shape = NULL; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_v_rhs_col_ptr = NULL; + PyObject *__pyx_v_rhs_row_ind = NULL; + PyObject *__pyx_v_rhs_val = NULL; + MUMPS_INT __pyx_v_x_length; + PyObject *__pyx_v_rhs_nnz = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + MUMPS_INT __pyx_t_8; + MUMPS_INT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *)__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_v_kwargs = __pyx_v_kwargs; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_kwargs); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_kwargs); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + __pyx_t_1 = ((!(__pyx_v_self->factorized != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":834 + * """ + * if not self.factorized: + * self.factorize() # <<<<<<<<<<<<<< + * + * transpose_solve = kwargs.get('transpose_solve', False) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_factorize); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":836 + * self.factorize() + * + * transpose_solve = kwargs.get('transpose_solve', False) # <<<<<<<<<<<<<< + * self.icntl[9] = 2 if transpose_solve else 1 + * + */ + __pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_transpose_solve, Py_False); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_transpose_solve = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":837 + * + * transpose_solve = kwargs.get('transpose_solve', False) + * self.icntl[9] = 2 if transpose_solve else 1 # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_transpose_solve); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__pyx_t_1) { + __Pyx_INCREF(__pyx_int_2); + __pyx_t_2 = __pyx_int_2; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_2 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 9, __pyx_t_2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_rhs, __pyx_cur_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":844 + * # rhs can be dense or sparse + * if 'rhs' in kwargs: + * rhs = kwargs['rhs'] # <<<<<<<<<<<<<< + * + * if not cnp.PyArray_Check(rhs): + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_5 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":850 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":855 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # create x + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":853 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":858 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (__pyx_t_7) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":862 + * # test number of columns in rhs + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * nrhs = rhs_shape[1] + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":864 + * nrhs = 1 + * else: + * nrhs = rhs_shape[1] # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = ((MUMPS_INT)__pyx_t_8); + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":866 + * nrhs = rhs_shape[1] + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((SMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_9, __pyx_v_nrhs); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_t_4 = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5solve_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_Generator_Next(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":870 + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] # <<<<<<<<<<<<<< + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_col_ptr); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_col_ptr = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":871 + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] # <<<<<<<<<<<<<< + * rhs_val = kwargs['rhs_val'] + * + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_row_ind); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_row_ind = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":872 + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] # <<<<<<<<<<<<<< + * + * # fortran indices, done internally in C: no efficiency lost + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_val); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 872; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_val = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":875 + * + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 # <<<<<<<<<<<<<< + * rhs_row_ind += 1 + * + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_col_ptr, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_col_ptr, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":876 + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 + * rhs_row_ind += 1 # <<<<<<<<<<<<<< + * + * nrhs = rhs_col_ptr.size - 1 + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_row_ind, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_row_ind, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":878 + * rhs_row_ind += 1 + * + * nrhs = rhs_col_ptr.size - 1 # <<<<<<<<<<<<<< + * x_length = self.nrow + * rhs_nnz = rhs_val.size + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_col_ptr, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = __pyx_t_8; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":879 + * + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow # <<<<<<<<<<<<<< + * rhs_nnz = rhs_val.size + * + */ + __pyx_t_9 = __pyx_v_self->nrow; + __pyx_v_x_length = __pyx_t_9; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":880 + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow + * rhs_nnz = rhs_val.size # <<<<<<<<<<<<<< + * + * x = np.zeros([self.nrow, nrhs], dtype=np.float32) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_val, __pyx_n_s_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 880; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_rhs_nnz = __pyx_t_4; + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":882 + * rhs_nnz = rhs_val.size + * + * x = np.zeros([self.nrow, nrhs], dtype=np.float32) # <<<<<<<<<<<<<< + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_nrhs); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float32); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_x = __pyx_t_6; + __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.float32) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + if (!(likely(((__pyx_v_rhs_col_ptr) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_col_ptr, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_rhs_row_ind) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_row_ind, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":885 + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), # <<<<<<<<<<<<<< + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + */ + if (!(likely(((__pyx_v_rhs_val) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_val, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 885; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":886 + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) # <<<<<<<<<<<<<< + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + */ + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_rhs_nnz); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.float32) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->solve_sparse(__pyx_v_self, ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_col_ptr))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_row_ind))), ((SMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_val))), __pyx_t_9, __pyx_v_nrhs, ((SMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_v_x_length); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L4:; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":890 + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + * + * return x # <<<<<<<<<<<<<< + * + * def refine(self, rhs, nitref = 3, tol=None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.solve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_transpose_solve); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XDECREF(__pyx_v_rhs_col_ptr); + __Pyx_XDECREF(__pyx_v_rhs_row_ind); + __Pyx_XDECREF(__pyx_v_rhs_val); + __Pyx_XDECREF(__pyx_v_rhs_nnz); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT32.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12refine[] = "\n refine(rhs, nitref) performs iterative refinement if necessary\n until the scaled residual norm ||b-Ax||/(1+||b||) falls below the\n threshold 'tol' or until nitref steps are taken.\n Parameters:\n nitref : < 0 : Fixed number of steps of iterative refinement. No stopping criterion is used. \n 0 : No iterative refinement.\n > 0 : Maximum number of steps of iterative refinement. A stopping criterion is used,\n therefore a test for convergence is done at each step of the iterative refinement algorithm.\n Default: 3\n tol : is the stopping criterion for iterative refinement\n\n Make sure you have called `solve()` with the same right-hand\n side rhs before calling `refine()`.\n The residual vector self.residual will be updated to reflect\n the updated approximate solution.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_rhs = 0; + PyObject *__pyx_v_nitref = 0; + PyObject *__pyx_v_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("refine (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rhs,&__pyx_n_s_nitref,&__pyx_n_s_tol,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)__pyx_int_3); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nitref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tol); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "refine") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_rhs = values[0]; + __pyx_v_nitref = values[1]; + __pyx_v_tol = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("refine", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12refine(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), __pyx_v_rhs, __pyx_v_nitref, __pyx_v_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12refine(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol) { + PyObject *__pyx_v_rhs_shape = NULL; + long __pyx_v_nrhs; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + MUMPS_INT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("refine", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_1 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":917 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":922 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs. + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":920 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":927 + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L5; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":929 + * nrhs = 1 + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ # <<<<<<<<<<<<<< + * "refinement.") + * + */ + /*else*/ { + __pyx_t_2 = PyNumber_Add(__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_kp_s_refinement); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L5:; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":933 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * self.icntl[10] = nitref + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":935 + * x = np.asfortranarray(rhs.copy()) + * + * self.icntl[10] = nitref # <<<<<<<<<<<<<< + * if tol is None: + * self.cntl[2] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_v_nitref, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + __pyx_t_1 = (__pyx_v_tol == Py_None); + __pyx_t_7 = (__pyx_t_1 != 0); + if (__pyx_t_7) { + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":937 + * self.icntl[10] = nitref + * if tol is None: + * self.cntl[2] = 0 # <<<<<<<<<<<<<< + * else: + * self.cntl[2] = tol + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":939 + * self.cntl[2] = 0 + * else: + * self.cntl[2] = tol # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_v_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L6:; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":941 + * self.cntl[2] = tol + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * # reset to default values + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_2); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((SMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_8, __pyx_v_nrhs); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":944 + * + * # reset to default values + * self.icntl[10] = 0 # <<<<<<<<<<<<<< + * self.cntl[2] = -1 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":945 + * # reset to default values + * self.icntl[10] = 0 + * self.cntl[2] = -1 # <<<<<<<<<<<<<< + * + * return x + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_neg_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":947 + * self.cntl[2] = -1 + * + * return x # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; + if (unlikely(__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_mumps_int_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_mumps_int_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT32.mumps_int_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_mumps_int_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_mumps_int_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Integer version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; + if (unlikely(__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_smumps_real_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_smumps_real_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT32.smumps_real_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_smumps_real_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_smumps_real_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Real version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + p->icntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->info = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->infog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->cntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfo = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)Py_None); Py_INCREF(Py_None); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + p->solve_stats = Py_None; Py_INCREF(Py_None); + if (unlikely(__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32(PyObject *o) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->icntl); + Py_CLEAR(p->info); + Py_CLEAR(p->infog); + Py_CLEAR(p->cntl); + Py_CLEAR(p->rinfo); + Py_CLEAR(p->rinfog); + Py_CLEAR(p->analysis_stats); + Py_CLEAR(p->factorize_stats); + Py_CLEAR(p->solve_stats); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)o; + if (p->icntl) { + e = (*v)(((PyObject*)p->icntl), a); if (e) return e; + } + if (p->info) { + e = (*v)(((PyObject*)p->info), a); if (e) return e; + } + if (p->infog) { + e = (*v)(((PyObject*)p->infog), a); if (e) return e; + } + if (p->cntl) { + e = (*v)(((PyObject*)p->cntl), a); if (e) return e; + } + if (p->rinfo) { + e = (*v)(((PyObject*)p->rinfo), a); if (e) return e; + } + if (p->rinfog) { + e = (*v)(((PyObject*)p->rinfog), a); if (e) return e; + } + if (p->analysis_stats) { + e = (*v)(p->analysis_stats, a); if (e) return e; + } + if (p->factorize_stats) { + e = (*v)(p->factorize_stats, a); if (e) return e; + } + if (p->solve_stats) { + e = (*v)(p->solve_stats, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)o; + tmp = ((PyObject*)p->icntl); + p->icntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->info); + p->info = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->infog); + p->infog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->cntl); + p->cntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfo); + p->rinfo = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfog); + p->rinfog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->analysis_stats); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->factorize_stats); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->solve_stats); + p->solve_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_analyzed(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8analyzed_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_factorized(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10factorized_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3sym_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_par(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_par(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3par_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_job(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_job(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3job_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_comm_fortran(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_comm_fortran(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12comm_fortran_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_icntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5icntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_n(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_n(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1n_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_alloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_alloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8nz_alloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_2nz_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3irn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3jcn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7irn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7jcn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nelt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nelt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nelt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltvar(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltvar(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6eltvar_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_perm_in(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_perm_in(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7perm_in_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8sym_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_uns_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_uns_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8uns_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11irhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_ptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_ptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8irhs_ptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_isol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_isol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8isol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4nrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4lrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lredrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lredrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7lredrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nz_rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lsol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lsol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lsol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_mloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_mloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_mloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_nloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_nloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10schur_nloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_lld(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_lld(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9schur_lld_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6mblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6nblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nprow(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nprow(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5nprow_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_npcol(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_npcol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5npcol_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_info(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4info_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_infog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5infog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_deficiency(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_deficiency(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10deficiency_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_pivnul_list(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_pivnul_list(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11pivnul_list_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mapping(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mapping(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7mapping_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_size_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_size_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10size_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_listvar_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_listvar_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13listvar_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_instance_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_instance_number(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_15instance_number_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_version_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_14version_number_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_tmpdir(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_tmpdir(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_tmpdir_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_prefix(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_prefix(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10ooc_prefix_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_write_problem(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_write_problem(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13write_problem_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lwk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lwk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8lwk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_cntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4cntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_1a_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_elt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_elt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5a_elt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_colsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_colsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6colsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rowsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rowsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rowsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_3rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_redrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_redrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6redrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10rhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7sol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rinfo(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5rinfo_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rinfog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6rinfog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_wk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_wk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7wk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32[] = { + {"set_silent", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_5set_silent, METH_NOARGS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_4set_silent}, + {"analyze", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_7analyze, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_6analyze}, + {"factorize", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_9factorize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_8factorize}, + {"solve", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_11solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_10solve}, + {"refine", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_13refine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_12refine}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32[] = { + {(char *)"analyzed", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_analyzed, 0, 0, 0}, + {(char *)"factorized", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_factorized, 0, 0, 0}, + {(char *)"sym", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym, 0, 0}, + {(char *)"par", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_par, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_par, 0, 0}, + {(char *)"job", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_job, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_job, 0, 0}, + {(char *)"comm_fortran", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_comm_fortran, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_comm_fortran, 0, 0}, + {(char *)"icntl", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_icntl, 0, 0, 0}, + {(char *)"n", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_n, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_n, 0, 0}, + {(char *)"nz_alloc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_alloc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_alloc, 0, 0}, + {(char *)"nz", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz, 0, 0}, + {(char *)"irn", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn, 0, 0}, + {(char *)"jcn", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn, 0, 0}, + {(char *)"nz_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_loc, 0, 0}, + {(char *)"irn_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irn_loc, 0, 0}, + {(char *)"jcn_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_jcn_loc, 0, 0}, + {(char *)"nelt", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nelt, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nelt, 0, 0}, + {(char *)"eltptr", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltptr, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltptr, 0, 0}, + {(char *)"eltvar", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltvar, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_eltvar, 0, 0}, + {(char *)"perm_in", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_perm_in, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_perm_in, 0, 0}, + {(char *)"sym_perm", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym_perm, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sym_perm, 0, 0}, + {(char *)"uns_perm", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_uns_perm, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_uns_perm, 0, 0}, + {(char *)"irhs_sparse", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_sparse, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_sparse, 0, 0}, + {(char *)"irhs_ptr", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_ptr, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_irhs_ptr, 0, 0}, + {(char *)"isol_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_isol_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_isol_loc, 0, 0}, + {(char *)"nrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nrhs, 0, 0}, + {(char *)"lrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lrhs, 0, 0}, + {(char *)"lredrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lredrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lredrhs, 0, 0}, + {(char *)"nz_rhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_rhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nz_rhs, 0, 0}, + {(char *)"lsol_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lsol_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lsol_loc, 0, 0}, + {(char *)"schur_mloc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_mloc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_mloc, 0, 0}, + {(char *)"schur_nloc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_nloc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_nloc, 0, 0}, + {(char *)"schur_lld", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_lld, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur_lld, 0, 0}, + {(char *)"mblock", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mblock, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mblock, 0, 0}, + {(char *)"nblock", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nblock, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nblock, 0, 0}, + {(char *)"nprow", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nprow, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_nprow, 0, 0}, + {(char *)"npcol", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_npcol, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_npcol, 0, 0}, + {(char *)"info", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_info, 0, 0, 0}, + {(char *)"infog", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_infog, 0, 0, 0}, + {(char *)"deficiency", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_deficiency, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_deficiency, 0, 0}, + {(char *)"pivnul_list", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_pivnul_list, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_pivnul_list, 0, 0}, + {(char *)"mapping", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mapping, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mapping, 0, 0}, + {(char *)"size_schur", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_size_schur, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_size_schur, 0, 0}, + {(char *)"listvar_schur", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_listvar_schur, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_listvar_schur, 0, 0}, + {(char *)"instance_number", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_instance_number, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_instance_number, 0, 0}, + {(char *)"version_number", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_version_number, 0, 0, 0}, + {(char *)"ooc_tmpdir", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_tmpdir, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_tmpdir, 0, 0}, + {(char *)"ooc_prefix", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_prefix, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_ooc_prefix, 0, 0}, + {(char *)"write_problem", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_write_problem, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_write_problem, 0, 0}, + {(char *)"lwk_user", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lwk_user, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_lwk_user, 0, 0}, + {(char *)"cntl", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_cntl, 0, 0, 0}, + {(char *)"a", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a, 0, 0}, + {(char *)"a_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_loc, 0, 0}, + {(char *)"a_elt", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_elt, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_a_elt, 0, 0}, + {(char *)"colsca", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_colsca, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_colsca, 0, 0}, + {(char *)"rowsca", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rowsca, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rowsca, 0, 0}, + {(char *)"rhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs, 0, 0}, + {(char *)"redrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_redrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_redrhs, 0, 0}, + {(char *)"rhs_sparse", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs_sparse, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rhs_sparse, 0, 0}, + {(char *)"sol_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sol_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_sol_loc, 0, 0}, + {(char *)"rinfo", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rinfo, 0, 0, 0}, + {(char *)"rinfog", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_rinfog, 0, 0, 0}, + {(char *)"schur", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_schur, 0, 0}, + {(char *)"wk_user", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_wk_user, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_wk_user, 0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT32.BaseMUMPSSolver_INT32_FLOAT32", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n Base MUMPS Context.\n\n This version **only** deals with array pointers.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve[8]; +static int __pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve[--__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve(PyObject *o) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_kwargs); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve)))) { + __pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve[__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve++] = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *)o; + if (p->__pyx_v_kwargs) { + e = (*v)(p->__pyx_v_kwargs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *)o; + tmp = ((PyObject*)p->__pyx_v_kwargs); + p->__pyx_v_kwargs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT32.__pyx_scope_struct__solve", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr[8]; +static int __pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr[--__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_arg); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr)))) { + __pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr[__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject*)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_arg) { + e = (*v)(p->__pyx_v_arg, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr *)o; + tmp = ((PyObject*)p->__pyx_outer_scope); + p->__pyx_outer_scope = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_arg); + p->__pyx_v_arg = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT32.__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "mumps_INT32_FLOAT32", + __pyx_k_This_is_the_base_class_for_the, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_AnalysisStatistics, __pyx_k_AnalysisStatistics, sizeof(__pyx_k_AnalysisStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_FactorizationStatistics, __pyx_k_FactorizationStatistics, sizeof(__pyx_k_FactorizationStatistics), 0, 0, 1, 1}, + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError, __pyx_k_MUMPSError, sizeof(__pyx_k_MUMPSError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError___init, __pyx_k_MUMPSError___init, sizeof(__pyx_k_MUMPSError___init), 0, 0, 1, 1}, + {&__pyx_kp_s_MUMPS_error, __pyx_k_MUMPS_error, sizeof(__pyx_k_MUMPS_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_failed_with_error, __pyx_k_MUMPS_failed_with_error, sizeof(__pyx_k_MUMPS_failed_with_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st, __pyx_k_MUMPS_index_must_be_1_Fortran_st, sizeof(__pyx_k_MUMPS_index_must_be_1_Fortran_st), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_d, __pyx_k_MUMPS_index_must_be_d, sizeof(__pyx_k_MUMPS_index_must_be_d), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_numerically_singular, __pyx_k_Matrix_is_numerically_singular, sizeof(__pyx_k_Matrix_is_numerically_singular), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_singular_in_structure, __pyx_k_Matrix_is_singular_in_structure, sizeof(__pyx_k_Matrix_is_singular_in_structure), 0, 0, 1, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_kp_s_Not_enough_memory, __pyx_k_Not_enough_memory, sizeof(__pyx_k_Not_enough_memory), 0, 0, 1, 0}, + {&__pyx_kp_s_Not_enough_memory_during_analysi, __pyx_k_Not_enough_memory_during_analysi, sizeof(__pyx_k_Not_enough_memory_during_analysi), 0, 0, 1, 0}, + {&__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_k_Only_one_dense_rhs_is_allowed_fo, sizeof(__pyx_k_Only_one_dense_rhs_is_allowed_fo), 0, 0, 1, 0}, + {&__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_k_Right_hand_side_has_wrong_sizeAt, sizeof(__pyx_k_Right_hand_side_has_wrong_sizeAt), 0, 0, 1, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_SolveStatistics, __pyx_k_SolveStatistics, sizeof(__pyx_k_SolveStatistics), 0, 0, 1, 1}, + {&__pyx_kp_s_The_authors_of_MUMPS_would_like, __pyx_k_The_authors_of_MUMPS_would_like, sizeof(__pyx_k_The_authors_of_MUMPS_would_like), 0, 0, 1, 0}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_k_Users_syarra_work_VirtualEnvs_n, sizeof(__pyx_k_Users_syarra_work_VirtualEnvs_n), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_amd, __pyx_k_amd, sizeof(__pyx_k_amd), 0, 0, 1, 1}, + {&__pyx_n_s_amf, __pyx_k_amf, sizeof(__pyx_k_amf), 0, 0, 1, 1}, + {&__pyx_n_s_analyze, __pyx_k_analyze, sizeof(__pyx_k_analyze), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_n_s_asfortranarray, __pyx_k_asfortranarray, sizeof(__pyx_k_asfortranarray), 0, 0, 1, 1}, + {&__pyx_n_s_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 0, 1, 1}, + {&__pyx_n_s_clock, __pyx_k_clock, sizeof(__pyx_k_clock), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_error_messages, __pyx_k_error_messages, sizeof(__pyx_k_error_messages), 0, 0, 1, 1}, + {&__pyx_n_s_factorize, __pyx_k_factorize, sizeof(__pyx_k_factorize), 0, 0, 1, 1}, + {&__pyx_n_s_float32, __pyx_k_float32, sizeof(__pyx_k_float32), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_infog, __pyx_k_infog, sizeof(__pyx_k_infog), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_metis, __pyx_k_metis, sizeof(__pyx_k_metis), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_mumps_statistics, __pyx_k_mumps_mumps_statistics, sizeof(__pyx_k_mumps_mumps_statistics), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_src_mumps_INT32_FLOAT32, __pyx_k_mumps_src_mumps_INT32_FLOAT32, sizeof(__pyx_k_mumps_src_mumps_INT32_FLOAT32), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_nitref, __pyx_k_nitref, sizeof(__pyx_k_nitref), 0, 0, 1, 1}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_ordering, __pyx_k_ordering, sizeof(__pyx_k_ordering), 0, 0, 1, 1}, + {&__pyx_n_s_ordering_name, __pyx_k_ordering_name, sizeof(__pyx_k_ordering_name), 0, 0, 1, 1}, + {&__pyx_n_s_orderings, __pyx_k_orderings, sizeof(__pyx_k_orderings), 0, 0, 1, 1}, + {&__pyx_n_s_pivot_tol, __pyx_k_pivot_tol, sizeof(__pyx_k_pivot_tol), 0, 0, 1, 1}, + {&__pyx_n_s_pord, __pyx_k_pord, sizeof(__pyx_k_pord), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_qamd, __pyx_k_qamd, sizeof(__pyx_k_qamd), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_kp_s_refinement, __pyx_k_refinement, sizeof(__pyx_k_refinement), 0, 0, 1, 0}, + {&__pyx_n_s_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_col_ptr, __pyx_k_rhs_col_ptr, sizeof(__pyx_k_rhs_col_ptr), 0, 0, 1, 1}, + {&__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP, __pyx_k_rhs_dense_arrays_must_be_an_NumP, sizeof(__pyx_k_rhs_dense_arrays_must_be_an_NumP), 0, 0, 1, 0}, + {&__pyx_kp_s_rhs_not_given_in_the_right_forma, __pyx_k_rhs_not_given_in_the_right_forma, sizeof(__pyx_k_rhs_not_given_in_the_right_forma), 0, 0, 1, 0}, + {&__pyx_n_s_rhs_row_ind, __pyx_k_rhs_row_ind, sizeof(__pyx_k_rhs_row_ind), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_val, __pyx_k_rhs_val, sizeof(__pyx_k_rhs_val), 0, 0, 1, 1}, + {&__pyx_n_s_scotch, __pyx_k_scotch, sizeof(__pyx_k_scotch), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, + {&__pyx_n_s_set_silent, __pyx_k_set_silent, sizeof(__pyx_k_set_silent), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, + {&__pyx_n_s_solve_locals_genexpr, __pyx_k_solve_locals_genexpr, sizeof(__pyx_k_solve_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, + {&__pyx_n_s_tol, __pyx_k_tol, sizeof(__pyx_k_tol), 0, 0, 1, 1}, + {&__pyx_n_s_transpose_solve, __pyx_k_transpose_solve, sizeof(__pyx_k_transpose_solve), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_kp_s_user_defined, __pyx_k_user_defined, sizeof(__pyx_k_user_defined), 0, 0, 1, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_tuple__3 = PyTuple_Pack(3, __pyx_n_s_rhs_col_ptr, __pyx_n_s_rhs_row_ind, __pyx_n_s_rhs_val); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_rhs_not_given_in_the_right_forma); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_tuple__13 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_infog, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_n_s_init, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_float_0_01 = PyFloat_FromDouble(0.01); if (unlikely(!__pyx_float_0_01)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_5 = PyInt_FromLong(-5); if (unlikely(!__pyx_int_neg_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_6 = PyInt_FromLong(-6); if (unlikely(!__pyx_int_neg_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_7 = PyInt_FromLong(-7); if (unlikely(!__pyx_int_neg_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_8 = PyInt_FromLong(-8); if (unlikely(!__pyx_int_neg_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_9 = PyInt_FromLong(-9); if (unlikely(!__pyx_int_neg_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_10 = PyInt_FromLong(-10); if (unlikely(!__pyx_int_neg_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_11 = PyInt_FromLong(-11); if (unlikely(!__pyx_int_neg_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_12 = PyInt_FromLong(-12); if (unlikely(!__pyx_int_neg_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_13 = PyInt_FromLong(-13); if (unlikely(!__pyx_int_neg_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initmumps_INT32_FLOAT32(void); /*proto*/ +PyMODINIT_FUNC initmumps_INT32_FLOAT32(void) +#else +PyMODINIT_FUNC PyInit_mumps_INT32_FLOAT32(void); /*proto*/ +PyMODINIT_FUNC PyInit_mumps_INT32_FLOAT32(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_mumps_INT32_FLOAT32(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("mumps_INT32_FLOAT32", __pyx_methods, __pyx_k_This_is_the_base_class_for_the, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__mumps_INT32_FLOAT32) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.mumps_INT32_FLOAT32")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.mumps_INT32_FLOAT32", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("c_to_fortran_index_array", (void (*)(void))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Type init code ---*/ + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array = &__pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array.tp_dict, __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "mumps_int_array", (PyObject *)&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array = &__pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *, SMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array.tp_dict, __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "smumps_real_array", (PyObject *)&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 = &__pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.get_data_pointers = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, MUMPS_INT *, MUMPS_INT *, SMUMPS_COMPLEX *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_get_data_pointers; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.initialize_mumps_struct = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, PyObject *, PyObject *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_initialize_mumps_struct; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.mumps_call = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_mumps_call; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.set_centralized_assembled_matrix = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_set_centralized_assembled_matrix; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.solve_dense = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, SMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_solve_dense; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.solve_sparse = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, MUMPS_INT *, MUMPS_INT *, SMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, SMUMPS_COMPLEX *, MUMPS_INT))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_29BaseMUMPSSolver_INT32_FLOAT32_solve_sparse; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32.tp_dict, __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "BaseMUMPSSolver_INT32_FLOAT32", (PyObject *)&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve.tp_print = 0; + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct__solve; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr.tp_print = 0; + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT32___pyx_scope_struct_1_genexpr; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":88 + * """ + * + * from mumps.mumps_statistics import AnalysisStatistics, FactorizationStatistics, SolveStatistics # <<<<<<<<<<<<<< + * + * from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free + */ + __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_AnalysisStatistics); + __Pyx_GIVEREF(__pyx_n_s_AnalysisStatistics); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_AnalysisStatistics); + __Pyx_INCREF(__pyx_n_s_FactorizationStatistics); + __Pyx_GIVEREF(__pyx_n_s_FactorizationStatistics); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_FactorizationStatistics); + __Pyx_INCREF(__pyx_n_s_SolveStatistics); + __Pyx_GIVEREF(__pyx_n_s_SolveStatistics); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_SolveStatistics); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_mumps_mumps_statistics, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AnalysisStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AnalysisStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FactorizationStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FactorizationStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SolveStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SolveStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":96 + * from libc.string cimport strncpy + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":99 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * import time + */ + import_array(); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":101 + * cnp.import_array() + * + * import time # <<<<<<<<<<<<<< + * + * cdef extern from "mumps_c_types.h": + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":214 + * + * # MUMPS possible ordering methods + * orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, # <<<<<<<<<<<<<< + * 'qamd' : 6, 'auto' : 7 } + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amd, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amf, __pyx_int_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scotch, __pyx_int_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_pord, __pyx_int_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_metis, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_qamd, __pyx_int_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_auto, __pyx_int_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_orderings, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":217 + * 'qamd' : 6, 'auto' : 7 } + * + * ordering_name = [ 'amd', 'user-defined', 'amf', # <<<<<<<<<<<<<< + * 'scotch', 'pord', 'metis', 'qamd'] + * + */ + __pyx_t_2 = PyList_New(7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_amd); + __Pyx_GIVEREF(__pyx_n_s_amd); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_amd); + __Pyx_INCREF(__pyx_kp_s_user_defined); + __Pyx_GIVEREF(__pyx_kp_s_user_defined); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_kp_s_user_defined); + __Pyx_INCREF(__pyx_n_s_amf); + __Pyx_GIVEREF(__pyx_n_s_amf); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_amf); + __Pyx_INCREF(__pyx_n_s_scotch); + __Pyx_GIVEREF(__pyx_n_s_scotch); + PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_scotch); + __Pyx_INCREF(__pyx_n_s_pord); + __Pyx_GIVEREF(__pyx_n_s_pord); + PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_pord); + __Pyx_INCREF(__pyx_n_s_metis); + __Pyx_GIVEREF(__pyx_n_s_metis); + PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_metis); + __Pyx_INCREF(__pyx_n_s_qamd); + __Pyx_GIVEREF(__pyx_n_s_qamd); + PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_qamd); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ordering_name, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":223 + * # TODO: decouple + * error_messages = { + * -5 : "Not enough memory during analysis phase", # <<<<<<<<<<<<<< + * -6 : "Matrix is singular in structure", + * -7 : "Not enough memory during analysis phase", + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_5, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_6, __pyx_kp_s_Matrix_is_singular_in_structure) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_7, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_10, __pyx_kp_s_Matrix_is_numerically_singular) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_11, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_12, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_13, __pyx_kp_s_Not_enough_memory) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_error_messages, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_builtin_RuntimeError); + __Pyx_GIVEREF(__pyx_builtin_RuntimeError); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_RuntimeError); + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_MUMPSError, __pyx_n_s_MUMPSError, (PyObject *) NULL, __pyx_n_s_mumps_src_mumps_INT32_FLOAT32, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5mumps_3src_19mumps_INT32_FLOAT32_10MUMPSError_1__init__, 0, __pyx_n_s_MUMPSError___init, NULL, __pyx_n_s_mumps_src_mumps_INT32_FLOAT32, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_init, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MUMPSError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MUMPSError, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT32.pyx":1 + * """ # <<<<<<<<<<<<<< + * This is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home) + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.mumps_INT32_FLOAT32", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.mumps_INT32_FLOAT32"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return NULL; + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#endif + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return -1; + } + } + return m->sq_ass_item(o, i, v); + } + } +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) { +#else + if (is_list || PySequence_Check(o)) { +#endif + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15 + default: return PyLong_Type.tp_richcompare(op1, op2, Py_EQ); + #else + default: Py_RETURN_FALSE; + #endif + } + } + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + return PyObject_RichCompare(op1, op2, Py_EQ); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); +#else + if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } else { + if (default_value == Py_None) + default_value = NULL; + value = PyObject_CallMethodObjArgs( + d, __pyx_n_s_get, key, default_value, NULL); + } +#endif + return value; +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_COMPILING_IN_CPYTHON + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyMem_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +#if CYTHON_COMPILING_IN_PYPY +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + PyObject *self = f->m_self; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0 = PySequence_ITEM(arg, 0); + if (unlikely(!arg0)) return NULL; + result = (*meth)(self, arg0); + Py_DECREF(arg0); + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +#else +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return PyCFunction_Call(func, arg, kw); +} +#endif +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_Call, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { +#if !CYTHON_COMPILING_IN_PYPY + __pyx_CyFunctionType_type.tp_call = PyCFunction_Call; +#endif + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (__pyx_CyFunctionType == NULL) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyMem_Malloc(size); + if (!m->defaults) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(MUMPS_INT) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(MUMPS_INT), + little, !is_unsigned); + } +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; +#else + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); +#endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto bad; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + args = PyTuple_New(2); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +bad: + Py_XDECREF(method); + return result; +} + +#include +#include +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { +#if PY_VERSION_HEX >= 0x030300A0 + if (ev && Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } +#endif + if (!ev || !PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + ev = Py_None; + } else if (PyTuple_Check(ev)) { + if (PyTuple_GET_SIZE(ev) >= 1) { + PyObject *value; +#if CYTHON_COMPILING_IN_CPYTHON + value = PySequence_ITEM(ev, 0); +#else + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#endif + Py_DECREF(ev); + ev = value; + } else { + Py_INCREF(Py_None); + Py_DECREF(ev); + ev = Py_None; + } + } + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = ev; + return 0; + } + } else if (!PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if PY_VERSION_HEX >= 0x030300A0 + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); +#else + { + PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); + Py_DECREF(ev); + if (likely(args)) { + value = PySequence_GetItem(args, 0); + Py_DECREF(args); + } + if (unlikely(!value)) { + __Pyx_ErrRestore(NULL, NULL, NULL); + Py_INCREF(Py_None); + value = Py_None; + } + } +#endif + *pvalue = value; + return 0; +} +#endif +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__pyx_CoroutineObject *self) { + PyObject *exc_type = self->exc_type; + PyObject *exc_value = self->exc_value; + PyObject *exc_traceback = self->exc_traceback; + self->exc_type = NULL; + self->exc_value = NULL; + self->exc_traceback = NULL; + Py_XDECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_traceback); +} +static CYTHON_INLINE +int __Pyx_Coroutine_CheckRunning(__pyx_CoroutineObject *gen) { + if (unlikely(gen->is_running)) { + PyErr_SetString(PyExc_ValueError, + "generator already executing"); + return 1; + } + return 0; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) { + PyObject *retval; + assert(!self->is_running); + if (unlikely(self->resume_label == 0)) { + if (unlikely(value && value != Py_None)) { + PyErr_SetString(PyExc_TypeError, + "can't send non-None value to a " + "just-started generator"); + return NULL; + } + } + if (unlikely(self->resume_label == -1)) { + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } + if (value) { +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyThreadState *tstate = PyThreadState_GET(); + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_XINCREF(tstate->frame); + assert(f->f_back == NULL); + f->f_back = tstate->frame; + } +#endif + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + self->is_running = 1; + retval = self->body((PyObject *) self, value); + self->is_running = 0; + if (retval) { + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + } +#endif + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_MethodReturn(PyObject *retval) { + if (unlikely(!retval && !PyErr_Occurred())) { + PyErr_SetNone(PyExc_StopIteration); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { + PyObject *ret; + PyObject *val = NULL; + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen_FetchStopIterationValue(&val); + ret = __Pyx_Coroutine_SendEx(gen, val); + Py_XDECREF(val); + return ret; +} +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + { + if (value == Py_None) + ret = PyIter_Next(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + } + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + retval = __Pyx_Coroutine_FinishDelegation(gen); + } else { + retval = __Pyx_Coroutine_SendEx(gen, value); + } + return __Pyx_Coroutine_MethodReturn(retval); +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + PyObject *retval = NULL; + int err = 0; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + { + PyObject *meth; + gen->is_running = 1; + meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + if (unlikely(!meth)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_WriteUnraisable(yf); + } + PyErr_Clear(); + } else { + retval = PyObject_CallFunction(meth, NULL); + Py_DECREF(meth); + if (!retval) + err = -1; + } + gen->is_running = 0; + } + Py_XDECREF(retval); + return err; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + ret = Py_TYPE(yf)->tp_iternext(yf); + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + return __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_SendEx(gen, Py_None); +} +static PyObject *__Pyx_Coroutine_Close(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *retval, *raised_exception; + PyObject *yf = gen->yieldfrom; + int err = 0; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + retval = __Pyx_Coroutine_SendEx(gen, NULL); + if (retval) { + Py_DECREF(retval); + PyErr_SetString(PyExc_RuntimeError, + "generator ignored GeneratorExit"); + return NULL; + } + raised_exception = PyErr_Occurred(); + if (!raised_exception + || raised_exception == PyExc_StopIteration + || raised_exception == PyExc_GeneratorExit + || PyErr_GivenExceptionMatches(raised_exception, PyExc_GeneratorExit) + || PyErr_GivenExceptionMatches(raised_exception, PyExc_StopIteration)) + { + if (raised_exception) PyErr_Clear(); + Py_INCREF(Py_None); + return Py_None; + } + return NULL; +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *typ; + PyObject *tb = NULL; + PyObject *val = NULL; + PyObject *yf = gen->yieldfrom; + if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + return NULL; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + Py_INCREF(yf); + if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit)) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); + goto throw_here; + } + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + { + PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + gen->is_running = 0; + return NULL; + } + PyErr_Clear(); + __Pyx_Coroutine_Undelegate(gen); + gen->is_running = 0; + goto throw_here; + } + ret = PyObject_CallObject(meth, args); + Py_DECREF(meth); + } + gen->is_running = 0; + Py_DECREF(yf); + if (!ret) { + ret = __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_MethodReturn(ret); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); +} +static int __Pyx_Coroutine_traverse(PyObject *self, visitproc visit, void *arg) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + Py_VISIT(gen->exc_type); + Py_VISIT(gen->exc_value); + Py_VISIT(gen->exc_traceback); + return 0; +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + Py_CLEAR(gen->yieldfrom); + Py_CLEAR(gen->exc_type); + Py_CLEAR(gen->exc_value); + Py_CLEAR(gen->exc_traceback); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label > 0) { + PyObject_GC_Track(self); +#if PY_VERSION_HEX >= 0x030400a1 + if (PyObject_CallFinalizerFromDealloc(self)) +#else + Py_TYPE(gen)->tp_del(self); + if (self->ob_refcnt > 0) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } + __Pyx_Coroutine_clear(self); + PyObject_GC_Del(gen); +} +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *res; + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + if (gen->resume_label <= 0) + return ; +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt == 0); + self->ob_refcnt = 1; +#endif + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + res = __Pyx_Coroutine_Close(self); + if (res == NULL) + PyErr_WriteUnraisable(self); + else + Py_DECREF(res); + __Pyx_ErrRestore(error_type, error_value, error_traceback); +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt > 0); + if (--self->ob_refcnt == 0) { + return; + } + { + Py_ssize_t refcnt = self->ob_refcnt; + _Py_NewReference(self); + self->ob_refcnt = refcnt; + } +#if CYTHON_COMPILING_IN_CPYTHON + assert(PyType_IS_GC(self->ob_type) && + _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); + _Py_DEC_REFTOTAL; +#endif +#ifdef COUNT_ALLOCS + --Py_TYPE(self)->tp_frees; + --Py_TYPE(self)->tp_allocs; +#endif +#endif +} +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_name); + return self->gi_name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = self->gi_name; + Py_INCREF(value); + self->gi_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_qualname); + return self->gi_qualname; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = self->gi_qualname; + Py_INCREF(value); + self->gi_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject* type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (gen == NULL) + return NULL; + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->exc_type = NULL; + gen->exc_value = NULL; + gen->exc_traceback = NULL; + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + PyObject_GC_Track(gen); + return gen; +} + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + int result; + PyObject *globals, *result_obj; + globals = PyDict_New(); if (unlikely(!globals)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_coroutine_type", + #ifdef __Pyx_Coroutine_USED + (PyObject*)__pyx_CoroutineType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_generator_type", + #ifdef __Pyx_Generator_USED + (PyObject*)__pyx_GeneratorType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; + result_obj = PyRun_String(py_code, Py_file_input, globals, globals); + if (unlikely(!result_obj)) goto ignore; + Py_DECREF(result_obj); + Py_DECREF(globals); + return module; +ignore: + Py_XDECREF(globals); + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + py_code++; +#endif + return module; +} + +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) +static PyObject* __Pyx_patch_abc_module(PyObject *module); +static PyObject* __Pyx_patch_abc_module(PyObject *module) { + module = __Pyx_Coroutine_patch_module( + module, "" +"if _cython_generator_type is not None:\n" +" try: Generator = _module.Generator\n" +" except AttributeError: pass\n" +" else: Generator.register(_cython_generator_type)\n" +"if _cython_coroutine_type is not None:\n" +" try: Coroutine = _module.Coroutine\n" +" except AttributeError: pass\n" +" else: Coroutine.register(_cython_coroutine_type)\n" + ); + return module; +} +#endif +static int __Pyx_patch_abc(void) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + static int abc_patched = 0; + if (!abc_patched) { + PyObject *module; + module = PyImport_ImportModule((PY_VERSION_HEX >= 0x03030000) ? "collections.abc" : "collections"); + if (!module) { + PyErr_WriteUnraisable(NULL); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, + ((PY_VERSION_HEX >= 0x03030000) ? + "Cython module failed to register with collections.abc module" : + "Cython module failed to register with collections module"), 1) < 0)) { + return -1; + } + } else { + module = __Pyx_patch_abc_module(module); + abc_patched = 1; + if (unlikely(!module)) + return -1; + Py_DECREF(module); + } + module = PyImport_ImportModule("backports_abc"); + if (module) { + module = __Pyx_patch_abc_module(module); + Py_XDECREF(module); + } + if (!module) { + PyErr_Clear(); + } + } +#else + if (0) __Pyx_Coroutine_patch_module(NULL, NULL); +#endif + return 0; +} + +static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the generator"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the generator"), 0}, + {0, 0, 0, 0, 0} +}; +static PyTypeObject __pyx_GeneratorType_type = { + PyVarObject_HEAD_INIT(0, 0) + "generator", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, + 0, + offsetof(__pyx_CoroutineObject, gi_weakreflist), + 0, + (iternextfunc) __Pyx_Generator_Next, + __pyx_Generator_methods, + __pyx_Generator_memberlist, + __pyx_Generator_getsets, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if PY_VERSION_HEX >= 0x030400a1 + __Pyx_Coroutine_del, +#endif +}; +static int __pyx_Generator_init(void) { + __pyx_GeneratorType_type.tp_getattro = PyObject_GenericGetAttr; + __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; + __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); + if (unlikely(!__pyx_GeneratorType)) { + return -1; + } + return 0; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0) + goto bad; + } + tmp.fp = f; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/mumps_INT32_FLOAT32.pxd b/mumps/src/mumps_INT32_FLOAT32.pxd new file mode 100644 index 0000000..0dcbb1c --- /dev/null +++ b/mumps/src/mumps_INT32_FLOAT32.pxd @@ -0,0 +1,186 @@ +cimport numpy as cnp + +cdef extern from "mumps_c_types.h": + + ctypedef int MUMPS_INT + ctypedef cnp.int8_t MUMPS_INT8 + + ctypedef float SMUMPS_COMPLEX + ctypedef float SMUMPS_REAL + + ctypedef double DMUMPS_COMPLEX + ctypedef double DMUMPS_REAL + + ctypedef struct mumps_complex: + float r,i + + ctypedef mumps_complex CMUMPS_COMPLEX + ctypedef float CMUMPS_REAL + + ctypedef struct mumps_double_complex: + double r, i + + ctypedef mumps_double_complex ZMUMPS_COMPLEX + ctypedef double ZMUMPS_REAL + +cdef extern from "smumps_c.h": + ctypedef struct SMUMPS_STRUC_C: + MUMPS_INT sym, par, job + MUMPS_INT comm_fortran # Fortran communicator + MUMPS_INT icntl[40] + MUMPS_INT keep[500] + SMUMPS_REAL cntl[15] + SMUMPS_REAL dkeep[130]; + MUMPS_INT8 keep8[150]; + MUMPS_INT n + + # used in matlab interface to decide if we + # free + malloc when we have large variation + MUMPS_INT nz_alloc + + # Assembled entry + MUMPS_INT nz + MUMPS_INT *irn + MUMPS_INT *jcn + SMUMPS_COMPLEX *a + + # Distributed entry + MUMPS_INT nz_loc + MUMPS_INT *irn_loc + MUMPS_INT *jcn_loc + SMUMPS_COMPLEX *a_loc + + # Element entry + MUMPS_INT nelt + MUMPS_INT *eltptr + MUMPS_INT *eltvar + SMUMPS_COMPLEX *a_elt + + # Ordering, if given by user + MUMPS_INT *perm_in + + # Orderings returned to user + MUMPS_INT *sym_perm # symmetric permutation + MUMPS_INT *uns_perm # column permutation + + # Scaling (input only in this version) + SMUMPS_REAL *colsca + SMUMPS_REAL *rowsca + MUMPS_INT colsca_from_mumps; + MUMPS_INT rowsca_from_mumps; + + + # RHS, solution, ouptput data and statistics + SMUMPS_COMPLEX *rhs + SMUMPS_COMPLEX *redrhs + SMUMPS_COMPLEX *rhs_sparse + SMUMPS_COMPLEX *sol_loc + MUMPS_INT *irhs_sparse + MUMPS_INT *irhs_ptr + MUMPS_INT *isol_loc + MUMPS_INT nrhs, lrhs, lredrhs, nz_rhs, lsol_loc + MUMPS_INT schur_mloc, schur_nloc, schur_lld + MUMPS_INT mblock, nblock, nprow, npcol + MUMPS_INT info[40] + MUMPS_INT infog[40] + SMUMPS_REAL rinfo[40] + SMUMPS_REAL rinfog[40] + + # Null space + MUMPS_INT deficiency + MUMPS_INT *pivnul_list + MUMPS_INT *mapping + + # Schur + MUMPS_INT size_schur + MUMPS_INT *listvar_schur + SMUMPS_COMPLEX *schur + + # Internal parameters + MUMPS_INT instance_number + SMUMPS_COMPLEX *wk_user + + char *version_number + # For out-of-core + char *ooc_tmpdir + char *ooc_prefix + # To save the matrix in matrix market format + char *write_problem + MUMPS_INT lwk_user + + cdef void smumps_c(SMUMPS_STRUC_C *) + +cdef class mumps_int_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + int version. + + """ + cdef: + MUMPS_INT * array + int ub + + cdef get_array(self, MUMPS_INT * array, int ub = ?) + +cdef class smumps_real_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + Real version. + + """ + cdef: + SMUMPS_REAL * array + int ub + + cdef get_array(self, SMUMPS_REAL * array, int ub = ?) + +cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + +cdef class BaseMUMPSSolver_INT32_FLOAT32: + cdef: + + MUMPS_INT nrow + MUMPS_INT ncol + MUMPS_INT nnz + + # MUMPS + SMUMPS_STRUC_C params + + # internal classes for getters and setters + mumps_int_array icntl + mumps_int_array info + mumps_int_array infog + + smumps_real_array cntl + smumps_real_array rinfo + smumps_real_array rinfog + + MUMPS_INT * a_row + MUMPS_INT * a_col + SMUMPS_COMPLEX * a_val + + bint analyzed + bint factorized + bint out_of_core + + object analysis_stats + object factorize_stats + object solve_stats + + cdef get_data_pointers(self, + MUMPS_INT * a_row, + MUMPS_INT * a_col, + SMUMPS_COMPLEX * a_val) + + cdef initialize_mumps_struct(self, comm_fortran, sym) + + cdef mumps_call(self) + + cdef set_centralized_assembled_matrix(self) + + cdef solve_dense(self, SMUMPS_COMPLEX * rhs, + MUMPS_INT rhs_length, MUMPS_INT nrhs) + cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + SMUMPS_COMPLEX * rhs_val, + MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + SMUMPS_COMPLEX * x, MUMPS_INT x_length) diff --git a/mumps/src/mumps_INT32_FLOAT32.pyx b/mumps/src/mumps_INT32_FLOAT32.pyx new file mode 100644 index 0000000..88bec81 --- /dev/null +++ b/mumps/src/mumps_INT32_FLOAT32.pyx @@ -0,0 +1,947 @@ +""" +This is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home) + +""" + +""" +Some notes for the maintainers of this library. + +Basic working: +-------------- + +MUMPS working is simple: + +- initialize/modify the C struct MUMPS_STRUC_C; +- call mumps_c(MUMPS_STRUC_C *). + +For example: + +# analyze +MUMPS_STRUC_C.job = 1 +mumps_c(&MUMPS_STRUC_C) + +# factorize +MUMPS_STRUC_C.job = 2 +mumps_c(&MUMPS_STRUC_C) + +# solve +MUMPS_STRUC_C.job = 3 +mumps_c(&MUMPS_STRUC_C) + +etc. + +Access to: + - icntl + - info + - infog + - cntl + - rinfo + - rinfog + +**must** be done through properties!!!! + + +Typed C struct: +--------------- + +Each MUMPS_STRUC_C is specialized and prefixed by a letter: + +- SMUMPS_STRUC_C: simple precision; +- DMUMPS_STRUC_C: double precision; +- CMUMPS_STRUC_C: simple complex; +- ZMUMPS_STRUC_C: double complex. + +In MUMPSContext_INT32_FLOAT32, (S,D,C,Z)mumps_c() is called by self.mumps_call(). + + can be used for **ALL** four types. + +Solve: +------ + +MUMPS **overwrites** the rhs member and replaces it by the solution(s) it finds. +If sparse solve is used, the solution is placed in a dummy dense rhs member. + +The rhs member can be a matrix or a vector. + +1-based index arrays: +--------------------- + +MUMPS uses exclusively FORTRAN routines and by consequence **all** array indices start with index **1** (not 0). + +Default 32 bit integers compilation: +------------------------------------ + +By default, MUMPS is compiled in 32 bit integers **unless** it is compiled with the option -DINTSIZE64. +32 and 64 bit versions are **not** compatible. + +Lib creation: +------------- + +The :file:`libmpiseq.so` file is *missing* by default in lib and must be added by hand. It is compiled in directory +libseq. :file:`libmpiseq.so` is essentially a dummy file to deal with sequential code. + +The order in which the library (.so) files are given to construct the MUMPS part +of this interface **is** important... and not standard. + +""" + +from mumps.mumps_statistics import AnalysisStatistics, FactorizationStatistics, SolveStatistics + +from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free +from cpython cimport Py_INCREF, Py_DECREF + +from libc.stdint cimport int64_t +from libc.string cimport strncpy + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + +import time + +cdef extern from "mumps_c_types.h": + + ctypedef int MUMPS_INT + ctypedef int64_t MUMPS_INT8 # warning: mumps uses "stdint.h" which might define int64_t as long long... + + ctypedef float SMUMPS_COMPLEX + ctypedef float SMUMPS_REAL + + ctypedef double DMUMPS_COMPLEX + ctypedef double DMUMPS_REAL + + ctypedef struct mumps_complex: + float r,i + + ctypedef mumps_complex CMUMPS_COMPLEX + ctypedef float CMUMPS_REAL + + ctypedef struct mumps_double_complex: + double r, i + + ctypedef mumps_double_complex ZMUMPS_COMPLEX + ctypedef double ZMUMPS_REAL + +cdef extern from "smumps_c.h": + ctypedef struct SMUMPS_STRUC_C: + MUMPS_INT sym, par, job + MUMPS_INT comm_fortran # Fortran communicator + MUMPS_INT icntl[40] + MUMPS_INT keep[500] + SMUMPS_REAL cntl[15] + SMUMPS_REAL dkeep[130]; + MUMPS_INT8 keep8[150]; + MUMPS_INT n + + # used in matlab interface to decide if we + # free + malloc when we have large variation + MUMPS_INT nz_alloc + + # Assembled entry + MUMPS_INT nz + MUMPS_INT *irn + MUMPS_INT *jcn + SMUMPS_COMPLEX *a + + # Distributed entry + MUMPS_INT nz_loc + MUMPS_INT *irn_loc + MUMPS_INT *jcn_loc + SMUMPS_COMPLEX *a_loc + + # Element entry + MUMPS_INT nelt + MUMPS_INT *eltptr + MUMPS_INT *eltvar + SMUMPS_COMPLEX *a_elt + + # Ordering, if given by user + MUMPS_INT *perm_in + + # Orderings returned to user + MUMPS_INT *sym_perm # symmetric permutation + MUMPS_INT *uns_perm # column permutation + + # Scaling (input only in this version) + SMUMPS_REAL *colsca + SMUMPS_REAL *rowsca + MUMPS_INT colsca_from_mumps; + MUMPS_INT rowsca_from_mumps; + + + # RHS, solution, ouptput data and statistics + SMUMPS_COMPLEX *rhs + SMUMPS_COMPLEX *redrhs + SMUMPS_COMPLEX *rhs_sparse + SMUMPS_COMPLEX *sol_loc + MUMPS_INT *irhs_sparse + MUMPS_INT *irhs_ptr + MUMPS_INT *isol_loc + MUMPS_INT nrhs, lrhs, lredrhs, nz_rhs, lsol_loc + MUMPS_INT schur_mloc, schur_nloc, schur_lld + MUMPS_INT mblock, nblock, nprow, npcol + MUMPS_INT info[40] + MUMPS_INT infog[40] + SMUMPS_REAL rinfo[40] + SMUMPS_REAL rinfog[40] + + # Null space + MUMPS_INT deficiency + MUMPS_INT *pivnul_list + MUMPS_INT *mapping + + # Schur + MUMPS_INT size_schur + MUMPS_INT *listvar_schur + SMUMPS_COMPLEX *schur + + # Internal parameters + MUMPS_INT instance_number + SMUMPS_COMPLEX *wk_user + + char *version_number + # For out-of-core + char *ooc_tmpdir + char *ooc_prefix + # To save the matrix in matrix market format + char *write_problem + MUMPS_INT lwk_user + + cdef void smumps_c(SMUMPS_STRUC_C *) + +# MUMPS possible ordering methods +orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, + 'qamd' : 6, 'auto' : 7 } + +ordering_name = [ 'amd', 'user-defined', 'amf', + 'scotch', 'pord', 'metis', 'qamd'] + +# MUMPS ERRORS +# TODO: decouple +error_messages = { + -5 : "Not enough memory during analysis phase", + -6 : "Matrix is singular in structure", + -7 : "Not enough memory during analysis phase", + -10 : "Matrix is numerically singular", + -11 : "The authors of MUMPS would like to hear about this", + -12 : "The authors of MUMPS would like to hear about this", + -13 : "Not enough memory" +} + + +class MUMPSError(RuntimeError): + def __init__(self, infog): + self.error = infog[1] + if self.error in error_messages: + msg = "{}. (MUMPS error {})".format( + error_messages[self.error], self.error) + else: + msg = "MUMPS failed with error {}.".format(self.error) + + RuntimeError.__init__(self, msg) + +# MUMPS HELPERS +cdef class mumps_int_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + + Integer version. + + """ + def __cinit__(self): + pass + + cdef get_array(self, MUMPS_INT * array, int ub = 40): + """ + Args: + ub: upper bound. + """ + self.ub = ub + self.array = array + + def __getitem__(self, key): + if key < 1: + raise IndexError('MUMPS index must be >= 1 (Fortran style)') + if key > self.ub: + raise IndexError('MUMPS index must be <= %d' % self.ub) + + return self.array[key - 1] + + def __setitem__(self, key, value): + self.array[key - 1] = value + +cdef class smumps_real_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + + Real version. + + """ + def __cinit__(self): + pass + + cdef get_array(self, SMUMPS_REAL * array, int ub = 40): + """ + Args: + ub: upper bound. + """ + self.ub = ub + self.array = array + + def __getitem__(self, key): + if key < 1: + raise IndexError('MUMPS index must be >= 1 (Fortran style)') + if key > self.ub: + raise IndexError('MUMPS index must be <= %d' % self.ub) + + return self.array[key - 1] + + def __setitem__(self, key, value): + self.array[key - 1] = value + + + +cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): + cdef: + MUMPS_INT i + + for i from 0 <= i < a_size: + a[i] += 1 + +# MUMPS CONTEXT +cdef class BaseMUMPSSolver_INT32_FLOAT32: + """ + Base MUMPS Context. + + This version **only** deals with array pointers. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + """ + + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + """ + self.nrow = n + self.ncol = n + self.nnz = nnz + + assert self.ncol == self.nrow + + self.initialize_mumps_struct(comm_fortran, sym) + + # `initialize_mumps_struct` **must** be called before assigning + # a value to n (size of the matrix) + self.params.n = self.nrow + + self.analyzed = False + self.factorized = False + self.out_of_core = False + + if not verbose: + self.set_silent() + + + cdef initialize_mumps_struct(self, comm_fortran, sym): + """ + Initialize MUMPS structure and make control parameters and information + avalaible to user. + + Args: + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + """ + self.params.job = -1 + self.params.sym = sym + self.params.par = 1 + + self.params.comm_fortran = comm_fortran + + self.mumps_call() + + # integer control parameters + self.icntl = mumps_int_array() + self.icntl.get_array(self.params.icntl) + + # integer information parameters + self.info = mumps_int_array() + self.info.get_array(self.params.info) + + # integer information parameters + self.infog = mumps_int_array() + self.infog.get_array(self.params.infog) + + # real/complex control parameters + self.cntl = smumps_real_array() + self.cntl.get_array(self.params.cntl) + + # real/complex information parameters + self.rinfo = smumps_real_array() + self.rinfo.get_array(self.params.rinfo) + + # real/complex information parameters + self.rinfog = smumps_real_array() + self.rinfog.get_array(self.params.rinfog) + + + cdef get_data_pointers(self, + MUMPS_INT * a_row, + MUMPS_INT * a_col, + SMUMPS_COMPLEX * a_val): + """ + Get elements of A and their positions and transfer them to MUMPS internal structure. + + Args: + a_row: pointer to an MUMPS_INT array containing row indices of non zero elements of A. + a_col: pointer to an MUMPS_INT array containing column indices of non zero elements of A. + a_val: pointer to an MUMPS_INT array containing values of non zeros elements of A. + + Note: row and column indices are adjusted for Fortran indexing. + """ + + self.a_row = a_row + self.a_col = a_col + self.a_val = a_val + + # transform c index arrays to fortran arrays + c_to_fortran_index_array(self.a_row, self.nnz) + c_to_fortran_index_array(self.a_col, self.nnz) + + self.set_centralized_assembled_matrix() + + + cdef set_centralized_assembled_matrix(self): + """ + Set the centralized assembled matrix + The rank 0 process supplies the entire matrix. + """ + + self.params.nz = self.nnz + + self.params.irn = self.a_row + self.params.jcn = self.a_col + self.params.a = self.a_val + + + def __dealloc__(self): + # autodestruct mumps internal + self.params.job = -2 + self.mumps_call() + self.params.job = -1 + self.mumps_call() + + # Properties + # COMMON Properties + property analyzed: + def __get__(self): return self.analyzed + property factorized: + def __get__(self): return self.factorized + property sym: + def __get__(self): return self.params.sym + def __set__(self, value): self.params.sym = value + property par: + def __get__(self): return self.params.par + def __set__(self, value): self.params.par = value + property job: + def __get__(self): return self.params.job + def __set__(self, value): self.params.job = value + + property comm_fortran: + def __get__(self): return self.params.comm_fortran + def __set__(self, value): self.params.comm_fortran = value + + property icntl: + def __get__(self): + return self.icntl + + property n: + def __get__(self): return self.params.n + def __set__(self, value): self.params.n = value + property nz_alloc: + def __get__(self): return self.params.nz_alloc + def __set__(self, value): self.params.nz_alloc = value + + property nz: + def __get__(self): return self.params.nz + def __set__(self, value): self.params.nz = value + property irn: + def __get__(self): return self.params.irn + def __set__(self, long value): self.params.irn = value + property jcn: + def __get__(self): return self.params.jcn + def __set__(self, long value): self.params.jcn = value + + property nz_loc: + def __get__(self): return self.params.nz_loc + def __set__(self, value): self.params.nz_loc = value + property irn_loc: + def __get__(self): return self.params.irn_loc + def __set__(self, long value): self.params.irn_loc = value + property jcn_loc: + def __get__(self): return self.params.jcn_loc + def __set__(self, long value): self.params.jcn_loc = value + + property nelt: + def __get__(self): return self.params.nelt + def __set__(self, value): self.params.nelt = value + property eltptr: + def __get__(self): return self.params.eltptr + def __set__(self, long value): self.params.eltptr = value + property eltvar: + def __get__(self): return self.params.eltvar + def __set__(self, long value): self.params.eltvar = value + + property perm_in: + def __get__(self): return self.params.perm_in + def __set__(self, long value): self.params.perm_in = value + + property sym_perm: + def __get__(self): return self.params.sym_perm + def __set__(self, long value): self.params.sym_perm = value + property uns_perm: + def __get__(self): return self.params.uns_perm + def __set__(self, long value): self.params.uns_perm = value + + property irhs_sparse: + def __get__(self): return self.params.irhs_sparse + def __set__(self, long value): self.params.irhs_sparse = value + property irhs_ptr: + def __get__(self): return self.params.irhs_ptr + def __set__(self, long value): self.params.irhs_ptr = value + property isol_loc: + def __get__(self): return self.params.isol_loc + def __set__(self, long value): self.params.isol_loc = value + + property nrhs: + def __get__(self): return self.params.nrhs + def __set__(self, value): self.params.nrhs = value + property lrhs: + def __get__(self): return self.params.lrhs + def __set__(self, value): self.params.lrhs = value + property lredrhs: + def __get__(self): return self.params.lredrhs + def __set__(self, value): self.params.lredrhs = value + property nz_rhs: + def __get__(self): return self.params.nz_rhs + def __set__(self, value): self.params.nz_rhs = value + property lsol_loc: + def __get__(self): return self.params.lsol_loc + def __set__(self, value): self.params.lsol_loc = value + + property schur_mloc: + def __get__(self): return self.params.schur_mloc + def __set__(self, value): self.params.schur_mloc = value + property schur_nloc: + def __get__(self): return self.params.schur_nloc + def __set__(self, value): self.params.schur_nloc = value + property schur_lld: + def __get__(self): return self.params.schur_lld + def __set__(self, value): self.params.schur_lld = value + + property mblock: + def __get__(self): return self.params.mblock + def __set__(self, value): self.params.mblock = value + property nblock: + def __get__(self): return self.params.nblock + def __set__(self, value): self.params.nblock = value + property nprow: + def __get__(self): return self.params.nprow + def __set__(self, value): self.params.nprow = value + property npcol: + def __get__(self): return self.params.npcol + def __set__(self, value): self.params.npcol = value + + property info: + def __get__(self): + return self.info + + property infog: + def __get__(self): + return self.infog + + property deficiency: + def __get__(self): return self.params.deficiency + def __set__(self, value): self.params.deficiency = value + property pivnul_list: + def __get__(self): return self.params.pivnul_list + def __set__(self, long value): self.params.pivnul_list = value + property mapping: + def __get__(self): return self.params.mapping + def __set__(self, long value): self.params.mapping = value + + property size_schur: + def __get__(self): return self.params.size_schur + def __set__(self, value): self.params.size_schur = value + property listvar_schur: + def __get__(self): return self.params.listvar_schur + def __set__(self, long value): self.params.listvar_schur = value + + property instance_number: + def __get__(self): return self.params.instance_number + def __set__(self, value): self.params.instance_number = value + + property version_number: + def __get__(self): + return ( self.params.version_number).decode('ascii') + + property ooc_tmpdir: + def __get__(self): + return ( self.params.ooc_tmpdir).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + property ooc_prefix: + def __get__(self): + return ( self.params.ooc_prefix).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + + property write_problem: + def __get__(self): + return ( self.params.write_problem).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + + property lwk_user: + def __get__(self): return self.params.lwk_user + def __set__(self, value): self.params.lwk_user = value + + # TYPED Properties + property cntl: + def __get__(self): + return self.cntl + + property a: + def __get__(self): return self.params.a + def __set__(self, long value): self.params.a = value + + property a_loc: + def __get__(self): return self.params.a_loc + def __set__(self, long value): self.params.a_loc = value + + property a_elt: + def __get__(self): return self.params.a_elt + def __set__(self, long value): self.params.a_elt = value + + property colsca: + def __get__(self): return self.params.colsca + def __set__(self, long value): self.params.colsca = value + property rowsca: + def __get__(self): return self.params.rowsca + def __set__(self, long value): self.params.rowsca = value + + property rhs: + def __get__(self): return self.params.rhs + def __set__(self, long value): self.params.rhs = value + property redrhs: + def __get__(self): return self.params.redrhs + def __set__(self, long value): self.params.redrhs = value + property rhs_sparse: + def __get__(self): return self.params.rhs_sparse + def __set__(self, long value): self.params.rhs_sparse = value + property sol_loc: + def __get__(self): return self.params.sol_loc + def __set__(self, long value): self.params.sol_loc = value + + property rinfo: + def __get__(self): + return self.rinfo + + property rinfog: + def __get__(self): + return self.rinfog + + property schur: + def __get__(self): return self.params.schur + def __set__(self, long value): self.params.schur = value + + property wk_user: + def __get__(self): return self.params.wk_user + def __set__(self, long value): self.params.wk_user = value + + # MUMPS CALL + cdef mumps_call(self): + """ + Call to Xmumps_c(XMUMPS_STRUC_C). + """ + smumps_c(&self.params) + + + def set_silent(self): + """ + Silence **all* MUMPS output. + + See MUMPS documentation. + """ + self.icntl[1] = 0 + self.icntl[2] = 0 + self.icntl[3] = 0 + self.icntl[4] = 0 + + + def analyze(self, ordering='auto'): + """ + Performs analysis step of MUMPS. + + In the analyis step, MUMPS is able to figure out a reordering for the + given matrix. It does so if `ordering` is set to 'auto'. + If not MUMPS will use the provided ordering. + MUMPS statistics for the analysis are available in `analysis_stats`. + + Args: + ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' } + ordering to use in the factorization. The availability of a + particular ordering depends on the MUMPS installation. Default is + 'auto'. + """ + if self.analyzed: + return + + self.icntl[7] = orderings[ordering] + t1 = time.clock() + self.params.job = 1 # analyse + self.mumps_call() + t2 = time.clock() + + if self.infog[1] < 0: + raise MUMPSError(self.infog) + + self.analyzed = True + + # self.analysis_stats = AnalysisStatistics(self.params, + # t2 - t1) + + def factorize(self, ordering='auto', pivot_tol=0.01): + """ + Perform the LU factorization of the matrix (or LDL' if the matrix + is symmetric). + + This factorization can then later be used to solve a linear system + with `solve`. Statistical data of the factorization is stored in + `factor_stats`. + + Args: + ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' } + ordering to use in the factorization. The availability of a + particular ordering depends on the MUMPS installation. Default is + 'auto'. + pivot_tol: number in the range [0, 1] + pivoting threshold. Pivoting is typically limited in sparse + solvers, as too much pivoting destroys sparsity. 1.0 means full + pivoting, whereas 0.0 means no pivoting. Default is 0.01. + """ + # TODO: ordering + + # Analysis phase must be done before factorization + if not self.analyzed : + self.analyze(ordering=ordering) + + self.icntl[22] = 1 if self.out_of_core else 1 + self.cntl[1] = pivot_tol + self.params.job = 2 + + done = False + while not done: + t1 = time.clock() + self.mumps_call() + t2 = time.clock() + + # error -8, -9 (not enough allocated memory) is treated + # specially, by increasing the memory relaxation parameter + if self.infog[1] < 0: + if self.infog[1] in (-8, -9): + # double the additional memory + self.icntl[14] = self.icntl[14]*2 + else: + raise MUMPSError(self.infog) + else: + done = True + + self.factorized = True + # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + + cdef solve_dense(self, SMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): + """ + Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + + Args: + rhs: the right hand side (dense matrix or vector) + rhs_length: Length of each column of the ``rhs``. + nrhs: Number of columns in the matrix ``rhs``. + + Warning: + MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + """ + self.params.nrhs = nrhs + self.params.lrhs = rhs_length + self.params.rhs = rhs + self.params.job = 3 # solve + self.mumps_call() + + cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + SMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + SMUMPS_COMPLEX * x, MUMPS_INT x_length): + """ + Solve a linear system after the LU (or LDL^t) factorization has previously been performed by `factorize` + + Args: + rhs_length: Length of each column of the ``rhs``. + nrhs: Number of columns in the matrix ``rhs``. + overwrite_rhs : ``True`` or ``False`` + whether the data in ``rhs`` may be overwritten, which can lead to a small + performance gain. Default is ``False``. + x : the solution to the linear system as a dense matrix or vector. + x_length: ``self.nrow`` (sequential version). + + Warning: + MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + + """ + self.params.nz_rhs = rhs_nnz + self.params.nrhs = nrhs # nrhs -1 ? + + self.params.rhs_sparse = rhs_val + self.params.irhs_sparse = rhs_row_ind + self.params.irhs_ptr = rhs_col_ptr + + # MUMPS places the solution(s) of the linear system in its dense rhs... + self.params.lrhs = x_length + self.params.rhs = x + + self.params.job = 3 # solve + self.icntl[20] = 1 # tell solver rhs is sparse + self.mumps_call() + + def solve(self, **kwargs): + """ + + Args: + rhs: dense NumPy array (matrix or vector). + rhs_col_ptr, rhs_row_ind, rhs_val: sparse NumPy CSC arrays (matrix or vector). + transpose_solve : ``True`` or ``False`` whether to solve A * x = rhs or A^T * x = rhs. Default is ``False`` + + Returns: + Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + """ + if not self.factorized: + self.factorize() + + transpose_solve = kwargs.get('transpose_solve', False) + self.icntl[9] = 2 if transpose_solve else 1 + + cdef: + MUMPS_INT nrhs + + # rhs can be dense or sparse + if 'rhs' in kwargs: + rhs = kwargs['rhs'] + + if not cnp.PyArray_Check(rhs): + raise TypeError('rhs dense arrays must be an NumPy array') + + # check is dimensions are OK + rhs_shape = rhs.shape + + if (rhs_shape[0] != self.nrow): + raise ValueError("Right hand side has wrong size" + "Attempting to solve the linear system, where A is of size (%d, %d) " + "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + + # create x + x = np.asfortranarray(rhs.copy()) + + # test number of columns in rhs + if rhs.ndim == 1: + nrhs = 1 + else: + nrhs = rhs_shape[1] + + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + + elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + + rhs_col_ptr = kwargs['rhs_col_ptr'] + rhs_row_ind = kwargs['rhs_row_ind'] + rhs_val = kwargs['rhs_val'] + + # fortran indices, done internally in C: no efficiency lost + rhs_col_ptr += 1 + rhs_row_ind += 1 + + nrhs = rhs_col_ptr.size - 1 + x_length = self.nrow + rhs_nnz = rhs_val.size + + x = np.zeros([self.nrow, nrhs], dtype=np.float32) + + self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + cnp.PyArray_DATA(rhs_val), + rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + else: + raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + + return x + + def refine(self, rhs, nitref = 3, tol=None): + """ + refine(rhs, nitref) performs iterative refinement if necessary + until the scaled residual norm ||b-Ax||/(1+||b||) falls below the + threshold 'tol' or until nitref steps are taken. + Parameters: + nitref : < 0 : Fixed number of steps of iterative refinement. No stopping criterion is used. + 0 : No iterative refinement. + > 0 : Maximum number of steps of iterative refinement. A stopping criterion is used, + therefore a test for convergence is done at each step of the iterative refinement algorithm. + Default: 3 + tol : is the stopping criterion for iterative refinement + + Make sure you have called `solve()` with the same right-hand + side rhs before calling `refine()`. + The residual vector self.residual will be updated to reflect + the updated approximate solution. + """ + cdef: + cnp.npy_intp dim[1] + + if not cnp.PyArray_Check(rhs): + raise TypeError('rhs dense arrays must be an NumPy array') + + # check is dimensions are OK + rhs_shape = rhs.shape + + if (rhs_shape[0] != self.nrow): + raise ValueError("Right hand side has wrong size" + "Attempting to solve the linear system, where A is of size (%d, %d) " + "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + + # test number of columns in rhs. + # Only one rhs is allowed when dense rhs is provided + if rhs.ndim == 1: + nrhs = 1 + else: + raise TypeError("Only one dense rhs is allowed for performing an iterative"+ + "refinement.") + + # create x + x = np.asfortranarray(rhs.copy()) + + self.icntl[10] = nitref + if tol is None: + self.cntl[2] = 0 + else: + self.cntl[2] = tol + + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + + # reset to default values + self.icntl[10] = 0 + self.cntl[2] = -1 + + return x \ No newline at end of file diff --git a/mumps/src/mumps_INT32_FLOAT64.c b/mumps/src/mumps_INT32_FLOAT64.c new file mode 100644 index 0000000..edda1a0 --- /dev/null +++ b/mumps/src/mumps_INT32_FLOAT64.c @@ -0,0 +1,19896 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__mumps_INT32_FLOAT64 +#define __PYX_HAVE_API__mumps__src__mumps_INT32_FLOAT64 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "dmumps_c.h" +#include "stdint.h" +#include "pythread.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/mumps_INT32_FLOAT64.pyx", + "__init__.pxd", + "type.pxd", + "bool.pxd", + "complex.pxd", +}; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class dmumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":135 + * int ub + * + * cdef get_array(self, DMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":113 + * cdef void dmumps_c(DMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class dmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_vtab; + DMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_FLOAT64: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + DMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + DMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve { + PyObject_HEAD + PyObject *__pyx_v_kwargs; +}; + + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr { + PyObject_HEAD + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *__pyx_outer_scope; + PyObject *__pyx_v_arg; +}; + + + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":245 + * + * # MUMPS HELPERS + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; + + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":274 + * self.array[key - 1] = value + * + * cdef class dmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *, DMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; + + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":313 + * + * # MUMPS CONTEXT + * cdef class BaseMUMPSSolver_INT32_FLOAT64: # <<<<<<<<<<<<<< + * """ + * Base MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, MUMPS_INT *, MUMPS_INT *, DMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, DMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, MUMPS_INT *, MUMPS_INT *, DMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, DMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o,n,NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_setattr)) + return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); +#endif + return PyObject_SetAttr(obj, attr_name, value); +} +#else +#define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name); + +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_SubtractObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceSubtract(op1, op2) : PyNumber_Subtract(op1, op2)) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); +#else +#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) +#endif + +static void __Pyx_WriteUnraisable(const char *name, int clineno, + int lineno, const char *filename, + int full_traceback, int nogil); + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +static CYTHON_INLINE PyObject* __Pyx_decode_bytes( + PyObject* string, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + return __Pyx_decode_c_bytes( + PyBytes_AS_STRING(string), PyBytes_GET_SIZE(string), + start, stop, encoding, errors, decode_func); +} + +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_EqObjC(op1, op2, intval, inplace)\ + PyObject_RichCompare(op1, op2, Py_EQ) + #endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname); + +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +#include + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases); + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); + +#define __Pyx_CyFunction_USED 1 +#include +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { + PyCFunctionObject func; +#if PY_VERSION_HEX < 0x030500A0 + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; + PyObject *func_classobj; + void *defaults; + int defaults_pyobjects; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; +} __pyx_CyFunctionObject; +static PyTypeObject *__pyx_CyFunctionType = 0; +#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\ + __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code) +static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *self, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(void); + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, PyObject *qualname, + PyObject *mkw, PyObject *modname, PyObject *doc); +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, PyObject *dict, + PyObject *mkw, int calculate_metaclass, int allow_py2_metaclass); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyObject *); +typedef struct { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; + PyObject *gi_weakreflist; + PyObject *classobj; + PyObject *yieldfrom; + PyObject *gi_name; + PyObject *gi_qualname; + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject *type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname); +static int __Pyx_Coroutine_clear(PyObject *self); +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue); +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue) PyGen_FetchStopIterationValue(pvalue) +#endif + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); + +static int __Pyx_patch_abc(void); + +#define __Pyx_Generator_USED +static PyTypeObject *__pyx_GeneratorType = 0; +#define __Pyx_Generator_CheckExact(obj) (Py_TYPE(obj) == __pyx_GeneratorType) +#define __Pyx_Generator_New(body, closure, name, qualname)\ + __Pyx__Coroutine_New(__pyx_GeneratorType, body, closure, name, qualname) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(void); + +static int __Pyx_check_binary_version(void); + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self, DMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array *__pyx_optional_args); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_get_data_pointers(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, DMUMPS_COMPLEX *__pyx_v_a_val); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mumps_call(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_solve_dense(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, DMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs); /* proto*/ +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_solve_sparse(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, DMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, DMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython.version' */ + +/* Module declarations from 'cpython.exc' */ + +/* Module declarations from 'cpython.module' */ + +/* Module declarations from 'cpython.mem' */ + +/* Module declarations from 'cpython.tuple' */ + +/* Module declarations from 'cpython.list' */ + +/* Module declarations from 'cpython.sequence' */ + +/* Module declarations from 'cpython.mapping' */ + +/* Module declarations from 'cpython.iterator' */ + +/* Module declarations from 'cpython.number' */ + +/* Module declarations from 'cpython.int' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.bool' */ +static PyTypeObject *__pyx_ptype_7cpython_4bool_bool = 0; + +/* Module declarations from 'cpython.long' */ + +/* Module declarations from 'cpython.float' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.complex' */ +static PyTypeObject *__pyx_ptype_7cpython_7complex_complex = 0; + +/* Module declarations from 'cpython.string' */ + +/* Module declarations from 'cpython.unicode' */ + +/* Module declarations from 'cpython.dict' */ + +/* Module declarations from 'cpython.instance' */ + +/* Module declarations from 'cpython.function' */ + +/* Module declarations from 'cpython.method' */ + +/* Module declarations from 'cpython.weakref' */ + +/* Module declarations from 'cpython.getargs' */ + +/* Module declarations from 'cpython.pythread' */ + +/* Module declarations from 'cpython.pystate' */ + +/* Module declarations from 'cpython.cobject' */ + +/* Module declarations from 'cpython.oldbuffer' */ + +/* Module declarations from 'cpython.set' */ + +/* Module declarations from 'cpython.bytes' */ + +/* Module declarations from 'cpython.pycapsule' */ + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'libc.stdint' */ + +/* Module declarations from 'mumps.src.mumps_INT32_FLOAT64' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr = 0; +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_c_to_fortran_index_array(MUMPS_INT *, MUMPS_INT); /*proto*/ +#define __Pyx_MODULE_NAME "mumps.src.mumps_INT32_FLOAT64" +int __pyx_module_is_main_mumps__src__mumps_INT32_FLOAT64 = 0; + +/* Implementation of 'mumps.src.mumps_INT32_FLOAT64' */ +static PyObject *__pyx_builtin_RuntimeError; +static PyObject *__pyx_builtin_IndexError; +static PyObject *__pyx_builtin_TypeError; +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_amd[] = "amd"; +static char __pyx_k_amf[] = "amf"; +static char __pyx_k_doc[] = "__doc__"; +static char __pyx_k_get[] = "get"; +static char __pyx_k_msg[] = "msg"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_rhs[] = "rhs"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_tol[] = "tol"; +static char __pyx_k_args[] = "args"; +static char __pyx_k_auto[] = "auto"; +static char __pyx_k_copy[] = "copy"; +static char __pyx_k_init[] = "__init__"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_ndim[] = "ndim"; +static char __pyx_k_pord[] = "pord"; +static char __pyx_k_qamd[] = "qamd"; +static char __pyx_k_self[] = "self"; +static char __pyx_k_send[] = "send"; +static char __pyx_k_size[] = "size"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_time[] = "time"; +static char __pyx_k_clock[] = "clock"; +static char __pyx_k_close[] = "close"; +static char __pyx_k_dtype[] = "dtype"; +static char __pyx_k_error[] = "error"; +static char __pyx_k_infog[] = "infog"; +static char __pyx_k_metis[] = "metis"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_shape[] = "shape"; +static char __pyx_k_throw[] = "throw"; +static char __pyx_k_zeros[] = "zeros"; +static char __pyx_k_format[] = "format"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_module[] = "__module__"; +static char __pyx_k_nitref[] = "nitref"; +static char __pyx_k_scotch[] = "scotch"; +static char __pyx_k_analyze[] = "analyze"; +static char __pyx_k_float64[] = "float64"; +static char __pyx_k_genexpr[] = "genexpr"; +static char __pyx_k_prepare[] = "__prepare__"; +static char __pyx_k_rhs_val[] = "rhs_val"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ordering[] = "ordering"; +static char __pyx_k_qualname[] = "__qualname__"; +static char __pyx_k_TypeError[] = "TypeError"; +static char __pyx_k_factorize[] = "factorize"; +static char __pyx_k_metaclass[] = "__metaclass__"; +static char __pyx_k_orderings[] = "orderings"; +static char __pyx_k_pivot_tol[] = "pivot_tol"; +static char __pyx_k_IndexError[] = "IndexError"; +static char __pyx_k_MUMPSError[] = "MUMPSError"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_refinement[] = "refinement."; +static char __pyx_k_set_silent[] = "set_silent"; +static char __pyx_k_MUMPS_error[] = "{}. (MUMPS error {})"; +static char __pyx_k_rhs_col_ptr[] = "rhs_col_ptr"; +static char __pyx_k_rhs_row_ind[] = "rhs_row_ind"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_user_defined[] = "user-defined"; +static char __pyx_k_ordering_name[] = "ordering_name"; +static char __pyx_k_asfortranarray[] = "asfortranarray"; +static char __pyx_k_error_messages[] = "error_messages"; +static char __pyx_k_SolveStatistics[] = "SolveStatistics"; +static char __pyx_k_transpose_solve[] = "transpose_solve"; +static char __pyx_k_MUMPSError___init[] = "MUMPSError.__init__"; +static char __pyx_k_Not_enough_memory[] = "Not enough memory"; +static char __pyx_k_AnalysisStatistics[] = "AnalysisStatistics"; +static char __pyx_k_solve_locals_genexpr[] = "solve..genexpr"; +static char __pyx_k_MUMPS_index_must_be_d[] = "MUMPS index must be <= %d"; +static char __pyx_k_mumps_mumps_statistics[] = "mumps.mumps_statistics"; +static char __pyx_k_FactorizationStatistics[] = "FactorizationStatistics"; +static char __pyx_k_MUMPS_failed_with_error[] = "MUMPS failed with error {}."; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_mumps_src_mumps_INT32_FLOAT64[] = "mumps.src.mumps_INT32_FLOAT64"; +static char __pyx_k_Matrix_is_numerically_singular[] = "Matrix is numerically singular"; +static char __pyx_k_This_is_the_base_class_for_the[] = "\nThis is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home)\n\n"; +static char __pyx_k_Matrix_is_singular_in_structure[] = "Matrix is singular in structure"; +static char __pyx_k_The_authors_of_MUMPS_would_like[] = "The authors of MUMPS would like to hear about this"; +static char __pyx_k_Users_syarra_work_VirtualEnvs_n[] = "/Users/syarra/work/VirtualEnvs/nlpy_new/programs/MUMPS.py/mumps/src/mumps_INT32_FLOAT64.pyx"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_MUMPS_index_must_be_1_Fortran_st[] = "MUMPS index must be >= 1 (Fortran style)"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_Not_enough_memory_during_analysi[] = "Not enough memory during analysis phase"; +static char __pyx_k_Only_one_dense_rhs_is_allowed_fo[] = "Only one dense rhs is allowed for performing an iterative"; +static char __pyx_k_Right_hand_side_has_wrong_sizeAt[] = "Right hand side has wrong sizeAttempting to solve the linear system, where A is of size (%d, %d) and rhs is of size (%g)"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_rhs_dense_arrays_must_be_an_NumP[] = "rhs dense arrays must be an NumPy array"; +static char __pyx_k_rhs_not_given_in_the_right_forma[] = "rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_n_s_AnalysisStatistics; +static PyObject *__pyx_n_s_FactorizationStatistics; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_n_s_MUMPSError; +static PyObject *__pyx_n_s_MUMPSError___init; +static PyObject *__pyx_kp_s_MUMPS_error; +static PyObject *__pyx_kp_s_MUMPS_failed_with_error; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st; +static PyObject *__pyx_kp_s_MUMPS_index_must_be_d; +static PyObject *__pyx_kp_s_Matrix_is_numerically_singular; +static PyObject *__pyx_kp_s_Matrix_is_singular_in_structure; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_kp_s_Not_enough_memory; +static PyObject *__pyx_kp_s_Not_enough_memory_during_analysi; +static PyObject *__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo; +static PyObject *__pyx_kp_s_Right_hand_side_has_wrong_sizeAt; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_SolveStatistics; +static PyObject *__pyx_kp_s_The_authors_of_MUMPS_would_like; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Users_syarra_work_VirtualEnvs_n; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_amd; +static PyObject *__pyx_n_s_amf; +static PyObject *__pyx_n_s_analyze; +static PyObject *__pyx_n_s_args; +static PyObject *__pyx_n_s_asfortranarray; +static PyObject *__pyx_n_s_auto; +static PyObject *__pyx_n_s_clock; +static PyObject *__pyx_n_s_close; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_copy; +static PyObject *__pyx_n_s_doc; +static PyObject *__pyx_n_s_dtype; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_error_messages; +static PyObject *__pyx_n_s_factorize; +static PyObject *__pyx_n_s_float64; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_genexpr; +static PyObject *__pyx_n_s_get; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_infog; +static PyObject *__pyx_n_s_init; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_metaclass; +static PyObject *__pyx_n_s_metis; +static PyObject *__pyx_n_s_module; +static PyObject *__pyx_n_s_msg; +static PyObject *__pyx_n_s_mumps_mumps_statistics; +static PyObject *__pyx_n_s_mumps_src_mumps_INT32_FLOAT64; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_nitref; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_ordering; +static PyObject *__pyx_n_s_ordering_name; +static PyObject *__pyx_n_s_orderings; +static PyObject *__pyx_n_s_pivot_tol; +static PyObject *__pyx_n_s_pord; +static PyObject *__pyx_n_s_prepare; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_qamd; +static PyObject *__pyx_n_s_qualname; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_kp_s_refinement; +static PyObject *__pyx_n_s_rhs; +static PyObject *__pyx_n_s_rhs_col_ptr; +static PyObject *__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP; +static PyObject *__pyx_kp_s_rhs_not_given_in_the_right_forma; +static PyObject *__pyx_n_s_rhs_row_ind; +static PyObject *__pyx_n_s_rhs_val; +static PyObject *__pyx_n_s_scotch; +static PyObject *__pyx_n_s_self; +static PyObject *__pyx_n_s_send; +static PyObject *__pyx_n_s_set_silent; +static PyObject *__pyx_n_s_shape; +static PyObject *__pyx_n_s_size; +static PyObject *__pyx_n_s_solve_locals_genexpr; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_n_s_throw; +static PyObject *__pyx_n_s_time; +static PyObject *__pyx_n_s_tol; +static PyObject *__pyx_n_s_transpose_solve; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_kp_s_user_defined; +static PyObject *__pyx_n_s_verbose; +static PyObject *__pyx_n_s_zeros; +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64___cinit__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose); /* proto */ +static void __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2__dealloc__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8analyzed___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10factorized___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5icntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4info___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5infog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_14version_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, char *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4cntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5rinfo___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rinfog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4set_silent(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6analyze(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_ordering); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8factorize(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5solve_genexpr(PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10solve(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12refine(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_float_0_01; +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_2; +static PyObject *__pyx_int_3; +static PyObject *__pyx_int_4; +static PyObject *__pyx_int_5; +static PyObject *__pyx_int_6; +static PyObject *__pyx_int_7; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_int_neg_5; +static PyObject *__pyx_int_neg_6; +static PyObject *__pyx_int_neg_7; +static PyObject *__pyx_int_neg_8; +static PyObject *__pyx_int_neg_9; +static PyObject *__pyx_int_neg_10; +static PyObject *__pyx_int_neg_11; +static PyObject *__pyx_int_neg_12; +static PyObject *__pyx_int_neg_13; +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; +static PyObject *__pyx_tuple__7; +static PyObject *__pyx_tuple__8; +static PyObject *__pyx_tuple__9; +static PyObject *__pyx_tuple__10; +static PyObject *__pyx_tuple__11; +static PyObject *__pyx_tuple__12; +static PyObject *__pyx_tuple__13; +static PyObject *__pyx_codeobj__14; + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError_1__init__ = {"__init__", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError_1__init__, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError_1__init__(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_self = 0; + PyObject *__pyx_v_infog = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_self,&__pyx_n_s_infog,0}; + PyObject* values[2] = {0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_self)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_infog)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_self = values[0]; + __pyx_v_infog = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError___init__(__pyx_self, __pyx_v_self, __pyx_v_infog); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError___init__(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_self, PyObject *__pyx_v_infog) { + PyObject *__pyx_v_msg = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":235 + * class MUMPSError(RuntimeError): + * def __init__(self, infog): + * self.error = infog[1] # <<<<<<<<<<<<<< + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + */ + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_infog, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_1 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_self, __pyx_n_s_error, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 235; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_t_2, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 236; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_4 = (__pyx_t_3 != 0); + if (__pyx_t_4) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":237 + * self.error = infog[1] + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( # <<<<<<<<<<<<<< + * error_messages[self.error], self.error) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":238 + * if self.error in error_messages: + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) # <<<<<<<<<<<<<< + * else: + * msg = "MUMPS failed with error {}.".format(self.error) + */ + __pyx_t_5 = __Pyx_GetModuleGlobalName(__pyx_n_s_error_messages); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyObject_GetItem(__pyx_t_5, __pyx_t_6); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 238; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_t_6); + __pyx_t_7 = 0; + __pyx_t_6 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 237; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":236 + * def __init__(self, infog): + * self.error = infog[1] + * if self.error in error_messages: # <<<<<<<<<<<<<< + * msg = "{}. (MUMPS error {})".format( + * error_messages[self.error], self.error) + */ + goto __pyx_L3; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":240 + * error_messages[self.error], self.error) + * else: + * msg = "MUMPS failed with error {}.".format(self.error) # <<<<<<<<<<<<<< + * + * RuntimeError.__init__(self, msg) + */ + /*else*/ { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_kp_s_MUMPS_failed_with_error, __pyx_n_s_format); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_self, __pyx_n_s_error); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + if (!__pyx_t_6) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_9); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 240; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_msg = __pyx_t_2; + __pyx_t_2 = 0; + } + __pyx_L3:; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":242 + * msg = "MUMPS failed with error {}.".format(self.error) + * + * RuntimeError.__init__(self, msg) # <<<<<<<<<<<<<< + * + * # MUMPS HELPERS + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_builtin_RuntimeError, __pyx_n_s_init); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + __pyx_t_8 = 1; + } + } + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_INCREF(__pyx_v_self); + __Pyx_GIVEREF(__pyx_v_self); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_v_self); + __Pyx_INCREF(__pyx_v_msg); + __Pyx_GIVEREF(__pyx_v_msg); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_msg); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_9, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 242; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.MUMPSError.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":252 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array___cinit__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self, MUMPS_INT *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":260 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":261 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":255 + * pass + * + * cdef get_array(self, MUMPS_INT * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_2__getitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 264; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":264 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 266; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":267 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 267; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":266 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":269 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 269; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":263 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.mumps_int_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_4__setitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":272 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * cdef class dmumps_real_array: + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 272; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":271 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.mumps_int_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":281 + * + * """ + * def __cinit__(self): # <<<<<<<<<<<<<< + * pass + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} + if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array___cinit__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":284 + * pass + * + * cdef get_array(self, DMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self, DMUMPS_REAL *__pyx_v_array, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array *__pyx_optional_args) { + int __pyx_v_ub = ((int)40); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_array", 0); + if (__pyx_optional_args) { + if (__pyx_optional_args->__pyx_n > 0) { + __pyx_v_ub = __pyx_optional_args->ub; + } + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":289 + * ub: upper bound. + * """ + * self.ub = ub # <<<<<<<<<<<<<< + * self.array = array + * + */ + __pyx_v_self->ub = __pyx_v_ub; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":290 + * """ + * self.ub = ub + * self.array = array # <<<<<<<<<<<<<< + * + * def __getitem__(self, key): + */ + __pyx_v_self->array = __pyx_v_array; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":284 + * pass + * + * cdef get_array(self, DMUMPS_REAL * array, int ub = 40): # <<<<<<<<<<<<<< + * """ + * Args: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_3__getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_2__getitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_2__getitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_key, __pyx_int_1, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 293; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":293 + * + * def __getitem__(self, key): + * if key < 1: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_key, __pyx_t_1, Py_GT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 295; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_2) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":296 + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) # <<<<<<<<<<<<<< + * + * return self.array[key - 1] + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->ub); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MUMPS_index_must_be_d, __pyx_t_3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_IndexError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 296; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":295 + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + * if key > self.ub: # <<<<<<<<<<<<<< + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":298 + * raise IndexError('MUMPS index must be <= %d' % self.ub) + * + * return self.array[key - 1] # <<<<<<<<<<<<<< + * + * def __setitem__(self, key, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_4 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyFloat_FromDouble((__pyx_v_self->array[__pyx_t_4])); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 298; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":292 + * self.array = array + * + * def __getitem__(self, key): # <<<<<<<<<<<<<< + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.dmumps_real_array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_5__setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_4__setitem__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_v_self), ((PyObject *)__pyx_v_key), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_4__setitem__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_v_self, PyObject *__pyx_v_key, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + DMUMPS_REAL __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":301 + * + * def __setitem__(self, key, value): + * self.array[key - 1] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_value); if (unlikely((__pyx_t_1 == (DMUMPS_REAL)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_PyInt_SubtractObjC(__pyx_v_key, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyIndex_AsSsize_t(__pyx_t_2); if (unlikely((__pyx_t_3 == (Py_ssize_t)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 301; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + (__pyx_v_self->array[__pyx_t_3]) = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":300 + * return self.array[key - 1] + * + * def __setitem__(self, key, value): # <<<<<<<<<<<<<< + * self.array[key - 1] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.dmumps_real_array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_c_to_fortran_index_array(MUMPS_INT *__pyx_v_a, MUMPS_INT __pyx_v_a_size) { + MUMPS_INT __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + MUMPS_INT __pyx_t_2; + __Pyx_RefNannySetupContext("c_to_fortran_index_array", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":309 + * MUMPS_INT i + * + * for i from 0 <= i < a_size: # <<<<<<<<<<<<<< + * a[i] += 1 + * + */ + __pyx_t_1 = __pyx_v_a_size; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_1; __pyx_v_i++) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":310 + * + * for i from 0 <= i < a_size: + * a[i] += 1 # <<<<<<<<<<<<<< + * + * # MUMPS CONTEXT + */ + __pyx_t_2 = __pyx_v_i; + (__pyx_v_a[__pyx_t_2]) = ((__pyx_v_a[__pyx_t_2]) + 1); + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":305 + * + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): # <<<<<<<<<<<<<< + * cdef: + * MUMPS_INT i + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + MUMPS_INT __pyx_v_n; + MUMPS_INT __pyx_v_nnz; + PyObject *__pyx_v_comm_fortran = 0; + PyObject *__pyx_v_sym = 0; + PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":324 + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 323; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64___cinit__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64___cinit__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, MUMPS_INT __pyx_v_n, MUMPS_INT __pyx_v_nnz, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym, PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":333 + * verbose: a boolean to turn on or off the verbosity of MUMPS + * """ + * self.nrow = n # <<<<<<<<<<<<<< + * self.ncol = n + * self.nnz = nnz + */ + __pyx_v_self->nrow = __pyx_v_n; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":334 + * """ + * self.nrow = n + * self.ncol = n # <<<<<<<<<<<<<< + * self.nnz = nnz + * + */ + __pyx_v_self->ncol = __pyx_v_n; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":335 + * self.nrow = n + * self.ncol = n + * self.nnz = nnz # <<<<<<<<<<<<<< + * + * assert self.ncol == self.nrow + */ + __pyx_v_self->nnz = __pyx_v_nnz; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":337 + * self.nnz = nnz + * + * assert self.ncol == self.nrow # <<<<<<<<<<<<<< + * + * self.initialize_mumps_struct(comm_fortran, sym) + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_self->ncol == __pyx_v_self->nrow) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 337; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":339 + * assert self.ncol == self.nrow + * + * self.initialize_mumps_struct(comm_fortran, sym) # <<<<<<<<<<<<<< + * + * # `initialize_mumps_struct` **must** be called before assigning + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->initialize_mumps_struct(__pyx_v_self, __pyx_v_comm_fortran, __pyx_v_sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 339; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":343 + * # `initialize_mumps_struct` **must** be called before assigning + * # a value to n (size of the matrix) + * self.params.n = self.nrow # <<<<<<<<<<<<<< + * + * self.analyzed = False + */ + __pyx_v_self->params.n = ((MUMPS_INT)__pyx_v_self->nrow); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":345 + * self.params.n = self.nrow + * + * self.analyzed = False # <<<<<<<<<<<<<< + * self.factorized = False + * self.out_of_core = False + */ + __pyx_v_self->analyzed = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":346 + * + * self.analyzed = False + * self.factorized = False # <<<<<<<<<<<<<< + * self.out_of_core = False + * + */ + __pyx_v_self->factorized = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":347 + * self.analyzed = False + * self.factorized = False + * self.out_of_core = False # <<<<<<<<<<<<<< + * + * if not verbose: + */ + __pyx_v_self->out_of_core = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_verbose); if (unlikely(__pyx_t_2 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 349; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_3 = ((!__pyx_t_2) != 0); + if (__pyx_t_3) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":350 + * + * if not verbose: + * self.set_silent() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_set_silent); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_5) { + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __pyx_t_1 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 350; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":349 + * self.out_of_core = False + * + * if not verbose: # <<<<<<<<<<<<<< + * self.set_silent() + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":323 + * """ + * + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_initialize_mumps_struct(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_comm_fortran, PyObject *__pyx_v_sym) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("initialize_mumps_struct", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":362 + * sym: a boolean indicating if A is a symmetric matrix or not + * """ + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.params.sym = sym + * self.params.par = 1 + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":363 + * """ + * self.params.job = -1 + * self.params.sym = sym # <<<<<<<<<<<<<< + * self.params.par = 1 + * + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_sym); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 363; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":364 + * self.params.job = -1 + * self.params.sym = sym + * self.params.par = 1 # <<<<<<<<<<<<<< + * + * self.params.comm_fortran = comm_fortran + */ + __pyx_v_self->params.par = 1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":366 + * self.params.par = 1 + * + * self.params.comm_fortran = comm_fortran # <<<<<<<<<<<<<< + * + * self.mumps_call() + */ + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_comm_fortran); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 366; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":368 + * self.params.comm_fortran = comm_fortran + * + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # integer control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 368; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":371 + * + * # integer control parameters + * self.icntl = mumps_int_array() # <<<<<<<<<<<<<< + * self.icntl.get_array(self.params.icntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 371; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->icntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_v_self->icntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":372 + * # integer control parameters + * self.icntl = mumps_int_array() + * self.icntl.get_array(self.params.icntl) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_v_self->icntl->__pyx_vtab)->get_array(__pyx_v_self->icntl, __pyx_v_self->params.icntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 372; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":375 + * + * # integer information parameters + * self.info = mumps_int_array() # <<<<<<<<<<<<<< + * self.info.get_array(self.params.info) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 375; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->info); + __Pyx_DECREF(((PyObject *)__pyx_v_self->info)); + __pyx_v_self->info = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":376 + * # integer information parameters + * self.info = mumps_int_array() + * self.info.get_array(self.params.info) # <<<<<<<<<<<<<< + * + * # integer information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_v_self->info->__pyx_vtab)->get_array(__pyx_v_self->info, __pyx_v_self->params.info, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 376; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":379 + * + * # integer information parameters + * self.infog = mumps_int_array() # <<<<<<<<<<<<<< + * self.infog.get_array(self.params.infog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 379; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->infog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->infog)); + __pyx_v_self->infog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":380 + * # integer information parameters + * self.infog = mumps_int_array() + * self.infog.get_array(self.params.infog) # <<<<<<<<<<<<<< + * + * # real/complex control parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)__pyx_v_self->infog->__pyx_vtab)->get_array(__pyx_v_self->infog, __pyx_v_self->params.infog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 380; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":383 + * + * # real/complex control parameters + * self.cntl = dmumps_real_array() # <<<<<<<<<<<<<< + * self.cntl.get_array(self.params.cntl) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 383; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->cntl); + __Pyx_DECREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_v_self->cntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":384 + * # real/complex control parameters + * self.cntl = dmumps_real_array() + * self.cntl.get_array(self.params.cntl) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_v_self->cntl->__pyx_vtab)->get_array(__pyx_v_self->cntl, __pyx_v_self->params.cntl, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 384; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":387 + * + * # real/complex information parameters + * self.rinfo = dmumps_real_array() # <<<<<<<<<<<<<< + * self.rinfo.get_array(self.params.rinfo) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 387; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfo); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_v_self->rinfo = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":388 + * # real/complex information parameters + * self.rinfo = dmumps_real_array() + * self.rinfo.get_array(self.params.rinfo) # <<<<<<<<<<<<<< + * + * # real/complex information parameters + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_v_self->rinfo->__pyx_vtab)->get_array(__pyx_v_self->rinfo, __pyx_v_self->params.rinfo, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 388; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":391 + * + * # real/complex information parameters + * self.rinfog = dmumps_real_array() # <<<<<<<<<<<<<< + * self.rinfog.get_array(self.params.rinfog) + * + */ + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array), __pyx_empty_tuple, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 391; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_self->rinfog); + __Pyx_DECREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_v_self->rinfog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":392 + * # real/complex information parameters + * self.rinfog = dmumps_real_array() + * self.rinfog.get_array(self.params.rinfog) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)__pyx_v_self->rinfog->__pyx_vtab)->get_array(__pyx_v_self->rinfog, __pyx_v_self->params.rinfog, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 392; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":353 + * + * + * cdef initialize_mumps_struct(self, comm_fortran, sym): # <<<<<<<<<<<<<< + * """ + * Initialize MUMPS structure and make control parameters and information + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.initialize_mumps_struct", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_get_data_pointers(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, MUMPS_INT *__pyx_v_a_row, MUMPS_INT *__pyx_v_a_col, DMUMPS_COMPLEX *__pyx_v_a_val) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_data_pointers", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":410 + * """ + * + * self.a_row = a_row # <<<<<<<<<<<<<< + * self.a_col = a_col + * self.a_val = a_val + */ + __pyx_v_self->a_row = ((MUMPS_INT *)__pyx_v_a_row); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":411 + * + * self.a_row = a_row + * self.a_col = a_col # <<<<<<<<<<<<<< + * self.a_val = a_val + * + */ + __pyx_v_self->a_col = ((MUMPS_INT *)__pyx_v_a_col); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":412 + * self.a_row = a_row + * self.a_col = a_col + * self.a_val = a_val # <<<<<<<<<<<<<< + * + * # transform c index arrays to fortran arrays + */ + __pyx_v_self->a_val = ((DMUMPS_COMPLEX *)__pyx_v_a_val); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":415 + * + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) # <<<<<<<<<<<<<< + * c_to_fortran_index_array(self.a_col, self.nnz) + * + */ + __pyx_t_1 = __pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_c_to_fortran_index_array(__pyx_v_self->a_row, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 415; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":416 + * # transform c index arrays to fortran arrays + * c_to_fortran_index_array(self.a_row, self.nnz) + * c_to_fortran_index_array(self.a_col, self.nnz) # <<<<<<<<<<<<<< + * + * self.set_centralized_assembled_matrix() + */ + __pyx_t_1 = __pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_c_to_fortran_index_array(__pyx_v_self->a_col, __pyx_v_self->nnz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 416; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":418 + * c_to_fortran_index_array(self.a_col, self.nnz) + * + * self.set_centralized_assembled_matrix() # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->set_centralized_assembled_matrix(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 418; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":395 + * + * + * cdef get_data_pointers(self, # <<<<<<<<<<<<<< + * MUMPS_INT * a_row, + * MUMPS_INT * a_col, + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.get_data_pointers", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_set_centralized_assembled_matrix(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_centralized_assembled_matrix", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":427 + * """ + * + * self.params.nz = self.nnz # <<<<<<<<<<<<<< + * + * self.params.irn = self.a_row + */ + __pyx_v_self->params.nz = ((MUMPS_INT)__pyx_v_self->nnz); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":429 + * self.params.nz = self.nnz + * + * self.params.irn = self.a_row # <<<<<<<<<<<<<< + * self.params.jcn = self.a_col + * self.params.a = self.a_val + */ + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_self->a_row); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":430 + * + * self.params.irn = self.a_row + * self.params.jcn = self.a_col # <<<<<<<<<<<<<< + * self.params.a = self.a_val + * + */ + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_self->a_col); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":431 + * self.params.irn = self.a_row + * self.params.jcn = self.a_col + * self.params.a = self.a_val # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_self->params.a = ((DMUMPS_COMPLEX *)__pyx_v_self->a_val); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":421 + * + * + * cdef set_centralized_assembled_matrix(self): # <<<<<<<<<<<<<< + * """ + * Set the centralized assembled matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + +/* Python wrapper */ +static void __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3__dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3__dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2__dealloc__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2__dealloc__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":436 + * def __dealloc__(self): + * # autodestruct mumps internal + * self.params.job = -2 # <<<<<<<<<<<<<< + * self.mumps_call() + * self.params.job = -1 + */ + __pyx_v_self->params.job = -2; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":437 + * # autodestruct mumps internal + * self.params.job = -2 + * self.mumps_call() # <<<<<<<<<<<<<< + * self.params.job = -1 + * self.mumps_call() + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 437; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":438 + * self.params.job = -2 + * self.mumps_call() + * self.params.job = -1 # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = -1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":439 + * self.mumps_call() + * self.params.job = -1 + * self.mumps_call() # <<<<<<<<<<<<<< + * + * # Properties + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 439; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":434 + * + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * # autodestruct mumps internal + * self.params.job = -2 + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_WriteUnraisable("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.__dealloc__", __pyx_clineno, __pyx_lineno, __pyx_filename, 0, 0); + __pyx_L0:; + __Pyx_RefNannyFinishContext(); +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":444 + * # COMMON Properties + * property analyzed: + * def __get__(self): return self.analyzed # <<<<<<<<<<<<<< + * property factorized: + * def __get__(self): return self.factorized + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8analyzed_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8analyzed_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8analyzed___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8analyzed___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->analyzed); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 444; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.analyzed.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":446 + * def __get__(self): return self.analyzed + * property factorized: + * def __get__(self): return self.factorized # <<<<<<<<<<<<<< + * property sym: + * def __get__(self): return self.params.sym + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10factorized_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10factorized_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10factorized___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10factorized___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->factorized); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 446; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.factorized.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":448 + * def __get__(self): return self.factorized + * property sym: + * def __get__(self): return self.params.sym # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.sym = value + * property par: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.sym); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 448; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.sym.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":449 + * property sym: + * def __get__(self): return self.params.sym + * def __set__(self, value): self.params.sym = value # <<<<<<<<<<<<<< + * property par: + * def __get__(self): return self.params.par + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 449; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.sym = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.sym.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":451 + * def __set__(self, value): self.params.sym = value + * property par: + * def __get__(self): return self.params.par # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.par = value + * property job: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.par); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 451; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.par.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":452 + * property par: + * def __get__(self): return self.params.par + * def __set__(self, value): self.params.par = value # <<<<<<<<<<<<<< + * property job: + * def __get__(self): return self.params.job + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 452; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.par = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.par.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":454 + * def __set__(self, value): self.params.par = value + * property job: + * def __get__(self): return self.params.job # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.job = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.job); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 454; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.job.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":455 + * property job: + * def __get__(self): return self.params.job + * def __set__(self, value): self.params.job = value # <<<<<<<<<<<<<< + * + * property comm_fortran: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 455; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.job = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.job.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":458 + * + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.comm_fortran = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.comm_fortran); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 458; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.comm_fortran.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":459 + * property comm_fortran: + * def __get__(self): return self.params.comm_fortran + * def __set__(self, value): self.params.comm_fortran = value # <<<<<<<<<<<<<< + * + * property icntl: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 459; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.comm_fortran = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.comm_fortran.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5icntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5icntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5icntl___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5icntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":463 + * property icntl: + * def __get__(self): + * return self.icntl # <<<<<<<<<<<<<< + * + * property n: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->icntl)); + __pyx_r = ((PyObject *)__pyx_v_self->icntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":462 + * + * property icntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.icntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":466 + * + * property n: + * def __get__(self): return self.params.n # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.n = value + * property nz_alloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.n); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 466; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.n.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":467 + * property n: + * def __get__(self): return self.params.n + * def __set__(self, value): self.params.n = value # <<<<<<<<<<<<<< + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 467; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.n = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.n.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":469 + * def __set__(self, value): self.params.n = value + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_alloc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_alloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 469; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz_alloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":470 + * property nz_alloc: + * def __get__(self): return self.params.nz_alloc + * def __set__(self, value): self.params.nz_alloc = value # <<<<<<<<<<<<<< + * + * property nz: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 470; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_alloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz_alloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":473 + * + * property nz: + * def __get__(self): return self.params.nz # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz = value + * property irn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 473; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":474 + * property nz: + * def __get__(self): return self.params.nz + * def __set__(self, value): self.params.nz = value # <<<<<<<<<<<<<< + * property irn: + * def __get__(self): return self.params.irn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 474; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":476 + * def __set__(self, value): self.params.nz = value + * property irn: + * def __get__(self): return self.params.irn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn = value + * property jcn: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 476; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":477 + * property irn: + * def __get__(self): return self.params.irn + * def __set__(self, long value): self.params.irn = value # <<<<<<<<<<<<<< + * property jcn: + * def __get__(self): return self.params.jcn + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 477; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":479 + * def __set__(self, long value): self.params.irn = value + * property jcn: + * def __get__(self): return self.params.jcn # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 479; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.jcn.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":480 + * property jcn: + * def __get__(self): return self.params.jcn + * def __set__(self, long value): self.params.jcn = value # <<<<<<<<<<<<<< + * + * property nz_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 480; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.jcn.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":483 + * + * property nz_loc: + * def __get__(self): return self.params.nz_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 483; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":484 + * property nz_loc: + * def __get__(self): return self.params.nz_loc + * def __set__(self, value): self.params.nz_loc = value # <<<<<<<<<<<<<< + * property irn_loc: + * def __get__(self): return self.params.irn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 484; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":486 + * def __set__(self, value): self.params.nz_loc = value + * property irn_loc: + * def __get__(self): return self.params.irn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 486; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":487 + * property irn_loc: + * def __get__(self): return self.params.irn_loc + * def __set__(self, long value): self.params.irn_loc = value # <<<<<<<<<<<<<< + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 487; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":489 + * def __set__(self, long value): self.params.irn_loc = value + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.jcn_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.jcn_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 489; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.jcn_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":490 + * property jcn_loc: + * def __get__(self): return self.params.jcn_loc + * def __set__(self, long value): self.params.jcn_loc = value # <<<<<<<<<<<<<< + * + * property nelt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 490; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.jcn_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.jcn_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":493 + * + * property nelt: + * def __get__(self): return self.params.nelt # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nelt = value + * property eltptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nelt); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 493; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nelt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":494 + * property nelt: + * def __get__(self): return self.params.nelt + * def __set__(self, value): self.params.nelt = value # <<<<<<<<<<<<<< + * property eltptr: + * def __get__(self): return self.params.eltptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 494; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nelt = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nelt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":496 + * def __set__(self, value): self.params.nelt = value + * property eltptr: + * def __get__(self): return self.params.eltptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 496; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.eltptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":497 + * property eltptr: + * def __get__(self): return self.params.eltptr + * def __set__(self, long value): self.params.eltptr = value # <<<<<<<<<<<<<< + * property eltvar: + * def __get__(self): return self.params.eltvar + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 497; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.eltptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":499 + * def __set__(self, long value): self.params.eltptr = value + * property eltvar: + * def __get__(self): return self.params.eltvar # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.eltvar = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.eltvar)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 499; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.eltvar.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":500 + * property eltvar: + * def __get__(self): return self.params.eltvar + * def __set__(self, long value): self.params.eltvar = value # <<<<<<<<<<<<<< + * + * property perm_in: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 500; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.eltvar.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.eltvar = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":503 + * + * property perm_in: + * def __get__(self): return self.params.perm_in # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.perm_in = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.perm_in)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 503; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.perm_in.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":504 + * property perm_in: + * def __get__(self): return self.params.perm_in + * def __set__(self, long value): self.params.perm_in = value # <<<<<<<<<<<<<< + * + * property sym_perm: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 504; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.perm_in.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.perm_in = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":507 + * + * property sym_perm: + * def __get__(self): return self.params.sym_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sym_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 507; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.sym_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":508 + * property sym_perm: + * def __get__(self): return self.params.sym_perm + * def __set__(self, long value): self.params.sym_perm = value # <<<<<<<<<<<<<< + * property uns_perm: + * def __get__(self): return self.params.uns_perm + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 508; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.sym_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sym_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":510 + * def __set__(self, long value): self.params.sym_perm = value + * property uns_perm: + * def __get__(self): return self.params.uns_perm # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.uns_perm = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.uns_perm)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 510; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.uns_perm.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":511 + * property uns_perm: + * def __get__(self): return self.params.uns_perm + * def __set__(self, long value): self.params.uns_perm = value # <<<<<<<<<<<<<< + * + * property irhs_sparse: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 511; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.uns_perm.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.uns_perm = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":514 + * + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 514; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":515 + * property irhs_sparse: + * def __get__(self): return self.params.irhs_sparse + * def __set__(self, long value): self.params.irhs_sparse = value # <<<<<<<<<<<<<< + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 515; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":517 + * def __set__(self, long value): self.params.irhs_sparse = value + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.irhs_ptr)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 517; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irhs_ptr.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":518 + * property irhs_ptr: + * def __get__(self): return self.params.irhs_ptr + * def __set__(self, long value): self.params.irhs_ptr = value # <<<<<<<<<<<<<< + * property isol_loc: + * def __get__(self): return self.params.isol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 518; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.irhs_ptr.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":520 + * def __set__(self, long value): self.params.irhs_ptr = value + * property isol_loc: + * def __get__(self): return self.params.isol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.isol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.isol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 520; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.isol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":521 + * property isol_loc: + * def __get__(self): return self.params.isol_loc + * def __set__(self, long value): self.params.isol_loc = value # <<<<<<<<<<<<<< + * + * property nrhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 521; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.isol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.isol_loc = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":524 + * + * property nrhs: + * def __get__(self): return self.params.nrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 524; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":525 + * property nrhs: + * def __get__(self): return self.params.nrhs + * def __set__(self, value): self.params.nrhs = value # <<<<<<<<<<<<<< + * property lrhs: + * def __get__(self): return self.params.lrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 525; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":527 + * def __set__(self, value): self.params.nrhs = value + * property lrhs: + * def __get__(self): return self.params.lrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 527; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":528 + * property lrhs: + * def __get__(self): return self.params.lrhs + * def __set__(self, value): self.params.lrhs = value # <<<<<<<<<<<<<< + * property lredrhs: + * def __get__(self): return self.params.lredrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 528; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":530 + * def __set__(self, value): self.params.lrhs = value + * property lredrhs: + * def __get__(self): return self.params.lredrhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lredrhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 530; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lredrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":531 + * property lredrhs: + * def __get__(self): return self.params.lredrhs + * def __set__(self, value): self.params.lredrhs = value # <<<<<<<<<<<<<< + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 531; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lredrhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lredrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":533 + * def __set__(self, value): self.params.lredrhs = value + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nz_rhs); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 533; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz_rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":534 + * property nz_rhs: + * def __get__(self): return self.params.nz_rhs + * def __set__(self, value): self.params.nz_rhs = value # <<<<<<<<<<<<<< + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 534; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nz_rhs = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nz_rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":536 + * def __set__(self, value): self.params.nz_rhs = value + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lsol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lsol_loc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 536; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lsol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":537 + * property lsol_loc: + * def __get__(self): return self.params.lsol_loc + * def __set__(self, value): self.params.lsol_loc = value # <<<<<<<<<<<<<< + * + * property schur_mloc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 537; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lsol_loc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lsol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":540 + * + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_mloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 540; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur_mloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":541 + * property schur_mloc: + * def __get__(self): return self.params.schur_mloc + * def __set__(self, value): self.params.schur_mloc = value # <<<<<<<<<<<<<< + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 541; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_mloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur_mloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":543 + * def __set__(self, value): self.params.schur_mloc = value + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_nloc); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 543; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur_nloc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":544 + * property schur_nloc: + * def __get__(self): return self.params.schur_nloc + * def __set__(self, value): self.params.schur_nloc = value # <<<<<<<<<<<<<< + * property schur_lld: + * def __get__(self): return self.params.schur_lld + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 544; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_nloc = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur_nloc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":546 + * def __set__(self, value): self.params.schur_nloc = value + * property schur_lld: + * def __get__(self): return self.params.schur_lld # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.schur_lld = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.schur_lld); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 546; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur_lld.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":547 + * property schur_lld: + * def __get__(self): return self.params.schur_lld + * def __set__(self, value): self.params.schur_lld = value # <<<<<<<<<<<<<< + * + * property mblock: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 547; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.schur_lld = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur_lld.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":550 + * + * property mblock: + * def __get__(self): return self.params.mblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.mblock = value + * property nblock: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.mblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 550; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.mblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":551 + * property mblock: + * def __get__(self): return self.params.mblock + * def __set__(self, value): self.params.mblock = value # <<<<<<<<<<<<<< + * property nblock: + * def __get__(self): return self.params.nblock + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 551; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.mblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.mblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":553 + * def __set__(self, value): self.params.mblock = value + * property nblock: + * def __get__(self): return self.params.nblock # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nblock = value + * property nprow: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nblock); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 553; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nblock.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":554 + * property nblock: + * def __get__(self): return self.params.nblock + * def __set__(self, value): self.params.nblock = value # <<<<<<<<<<<<<< + * property nprow: + * def __get__(self): return self.params.nprow + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 554; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nblock = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nblock.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":556 + * def __set__(self, value): self.params.nblock = value + * property nprow: + * def __get__(self): return self.params.nprow # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.nprow = value + * property npcol: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.nprow); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 556; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nprow.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":557 + * property nprow: + * def __get__(self): return self.params.nprow + * def __set__(self, value): self.params.nprow = value # <<<<<<<<<<<<<< + * property npcol: + * def __get__(self): return self.params.npcol + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 557; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.nprow = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.nprow.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":559 + * def __set__(self, value): self.params.nprow = value + * property npcol: + * def __get__(self): return self.params.npcol # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.npcol = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.npcol); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 559; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.npcol.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":560 + * property npcol: + * def __get__(self): return self.params.npcol + * def __set__(self, value): self.params.npcol = value # <<<<<<<<<<<<<< + * + * property info: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 560; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.npcol = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.npcol.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4info_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4info_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4info___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4info___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":564 + * property info: + * def __get__(self): + * return self.info # <<<<<<<<<<<<<< + * + * property infog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->info)); + __pyx_r = ((PyObject *)__pyx_v_self->info); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":563 + * + * property info: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.info + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5infog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5infog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5infog___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5infog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":568 + * property infog: + * def __get__(self): + * return self.infog # <<<<<<<<<<<<<< + * + * property deficiency: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __pyx_r = ((PyObject *)__pyx_v_self->infog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":567 + * + * property infog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.infog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":571 + * + * property deficiency: + * def __get__(self): return self.params.deficiency # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.deficiency); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 571; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.deficiency.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":572 + * property deficiency: + * def __get__(self): return self.params.deficiency + * def __set__(self, value): self.params.deficiency = value # <<<<<<<<<<<<<< + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 572; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.deficiency = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.deficiency.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":574 + * def __set__(self, value): self.params.deficiency = value + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.pivnul_list)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 574; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.pivnul_list.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":575 + * property pivnul_list: + * def __get__(self): return self.params.pivnul_list + * def __set__(self, long value): self.params.pivnul_list = value # <<<<<<<<<<<<<< + * property mapping: + * def __get__(self): return self.params.mapping + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 575; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.pivnul_list.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.pivnul_list = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":577 + * def __set__(self, long value): self.params.pivnul_list = value + * property mapping: + * def __get__(self): return self.params.mapping # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.mapping = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.mapping)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 577; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.mapping.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":578 + * property mapping: + * def __get__(self): return self.params.mapping + * def __set__(self, long value): self.params.mapping = value # <<<<<<<<<<<<<< + * + * property size_schur: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 578; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.mapping.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.mapping = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":581 + * + * property size_schur: + * def __get__(self): return self.params.size_schur # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.size_schur); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 581; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.size_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":582 + * property size_schur: + * def __get__(self): return self.params.size_schur + * def __set__(self, value): self.params.size_schur = value # <<<<<<<<<<<<<< + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 582; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.size_schur = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.size_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":584 + * def __set__(self, value): self.params.size_schur = value + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.listvar_schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.listvar_schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 584; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.listvar_schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":585 + * property listvar_schur: + * def __get__(self): return self.params.listvar_schur + * def __set__(self, long value): self.params.listvar_schur = value # <<<<<<<<<<<<<< + * + * property instance_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 585; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.listvar_schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.listvar_schur = ((MUMPS_INT *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":588 + * + * property instance_number: + * def __get__(self): return self.params.instance_number # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.instance_number = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.instance_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 588; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.instance_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":589 + * property instance_number: + * def __get__(self): return self.params.instance_number + * def __set__(self, value): self.params.instance_number = value # <<<<<<<<<<<<<< + * + * property version_number: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 589; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.instance_number = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.instance_number.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_14version_number_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_14version_number_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_14version_number___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_14version_number___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":593 + * property version_number: + * def __get__(self): + * return ( self.params.version_number).decode('ascii') # <<<<<<<<<<<<<< + * + * property ooc_tmpdir: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.version_number); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 593; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":592 + * + * property version_number: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.version_number).decode('ascii') + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.version_number.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":597 + * property ooc_tmpdir: + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_tmpdir); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 597; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":596 + * + * property ooc_tmpdir: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.ooc_tmpdir.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 598; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.ooc_tmpdir.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":599 + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) # <<<<<<<<<<<<<< + * property ooc_prefix: + * def __get__(self): + */ + strncpy(__pyx_v_self->params.ooc_tmpdir, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_tmpdir))); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":598 + * def __get__(self): + * return ( self.params.ooc_tmpdir).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":602 + * property ooc_prefix: + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.ooc_prefix); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 602; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":601 + * strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + * property ooc_prefix: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.ooc_prefix.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 603; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.ooc_prefix.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":604 + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) # <<<<<<<<<<<<<< + * + * property write_problem: + */ + strncpy(__pyx_v_self->params.ooc_prefix, __pyx_v_value, (sizeof(__pyx_v_self->params.ooc_prefix))); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":603 + * def __get__(self): + * return ( self.params.ooc_prefix).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":608 + * property write_problem: + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') # <<<<<<<<<<<<<< + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->params.write_problem); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%s'", "decode"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_2 = __Pyx_decode_bytes(((PyObject*)__pyx_t_1), 0, PY_SSIZE_T_MAX, NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 608; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":607 + * + * property write_problem: + * def __get__(self): # <<<<<<<<<<<<<< + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.write_problem.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + char *__pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyObject_AsString(__pyx_arg_value); if (unlikely((!__pyx_v_value) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 609; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.write_problem.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((char *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, char *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":610 + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) # <<<<<<<<<<<<<< + * + * property lwk_user: + */ + strncpy(__pyx_v_self->params.write_problem, __pyx_v_value, (sizeof(__pyx_v_self->params.write_problem))); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":609 + * def __get__(self): + * return ( self.params.write_problem).decode('ascii') + * def __set__(self, char *value): # <<<<<<<<<<<<<< + * strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + * + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":613 + * + * property lwk_user: + * def __get__(self): return self.params.lwk_user # <<<<<<<<<<<<<< + * def __set__(self, value): self.params.lwk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->params.lwk_user); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 613; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lwk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":614 + * property lwk_user: + * def __get__(self): return self.params.lwk_user + * def __set__(self, value): self.params.lwk_user = value # <<<<<<<<<<<<<< + * + * # TYPED Properties + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + MUMPS_INT __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_t_1 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_value); if (unlikely((__pyx_t_1 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 614; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_self->params.lwk_user = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.lwk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4cntl_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4cntl_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4cntl___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4cntl___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":619 + * property cntl: + * def __get__(self): + * return self.cntl # <<<<<<<<<<<<<< + * + * property a: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->cntl)); + __pyx_r = ((PyObject *)__pyx_v_self->cntl); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":618 + * # TYPED Properties + * property cntl: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.cntl + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":622 + * + * property a: + * def __get__(self): return self.params.a # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 622; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.a.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":623 + * property a: + * def __get__(self): return self.params.a + * def __set__(self, long value): self.params.a = value # <<<<<<<<<<<<<< + * + * property a_loc: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 623; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.a.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":626 + * + * property a_loc: + * def __get__(self): return self.params.a_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 626; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.a_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":627 + * property a_loc: + * def __get__(self): return self.params.a_loc + * def __set__(self, long value): self.params.a_loc = value # <<<<<<<<<<<<<< + * + * property a_elt: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 627; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.a_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_loc = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":630 + * + * property a_elt: + * def __get__(self): return self.params.a_elt # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.a_elt = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.a_elt)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 630; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.a_elt.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":631 + * property a_elt: + * def __get__(self): return self.params.a_elt + * def __set__(self, long value): self.params.a_elt = value # <<<<<<<<<<<<<< + * + * property colsca: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 631; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.a_elt.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.a_elt = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":634 + * + * property colsca: + * def __get__(self): return self.params.colsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.colsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 634; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.colsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":635 + * property colsca: + * def __get__(self): return self.params.colsca + * def __set__(self, long value): self.params.colsca = value # <<<<<<<<<<<<<< + * property rowsca: + * def __get__(self): return self.params.rowsca + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 635; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.colsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.colsca = ((DMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":637 + * def __set__(self, long value): self.params.colsca = value + * property rowsca: + * def __get__(self): return self.params.rowsca # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rowsca = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rowsca)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 637; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.rowsca.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":638 + * property rowsca: + * def __get__(self): return self.params.rowsca + * def __set__(self, long value): self.params.rowsca = value # <<<<<<<<<<<<<< + * + * property rhs: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 638; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.rowsca.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rowsca = ((DMUMPS_REAL *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":641 + * + * property rhs: + * def __get__(self): return self.params.rhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 641; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.rhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":642 + * property rhs: + * def __get__(self): return self.params.rhs + * def __set__(self, long value): self.params.rhs = value # <<<<<<<<<<<<<< + * property redrhs: + * def __get__(self): return self.params.redrhs + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 642; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.rhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":644 + * def __set__(self, long value): self.params.rhs = value + * property redrhs: + * def __get__(self): return self.params.redrhs # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.redrhs)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 644; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.redrhs.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":645 + * property redrhs: + * def __get__(self): return self.params.redrhs + * def __set__(self, long value): self.params.redrhs = value # <<<<<<<<<<<<<< + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 645; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.redrhs.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.redrhs = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":647 + * def __set__(self, long value): self.params.redrhs = value + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.rhs_sparse)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 647; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.rhs_sparse.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":648 + * property rhs_sparse: + * def __get__(self): return self.params.rhs_sparse + * def __set__(self, long value): self.params.rhs_sparse = value # <<<<<<<<<<<<<< + * property sol_loc: + * def __get__(self): return self.params.sol_loc + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 648; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.rhs_sparse.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.rhs_sparse = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":650 + * def __set__(self, long value): self.params.rhs_sparse = value + * property sol_loc: + * def __get__(self): return self.params.sol_loc # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.sol_loc = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.sol_loc)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 650; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.sol_loc.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":651 + * property sol_loc: + * def __get__(self): return self.params.sol_loc + * def __set__(self, long value): self.params.sol_loc = value # <<<<<<<<<<<<<< + * + * property rinfo: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 651; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.sol_loc.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.sol_loc = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5rinfo_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5rinfo_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5rinfo___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5rinfo___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":655 + * property rinfo: + * def __get__(self): + * return self.rinfo # <<<<<<<<<<<<<< + * + * property rinfog: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfo)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfo); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":654 + * + * property rinfo: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfo + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rinfog_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rinfog_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rinfog___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rinfog___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":659 + * property rinfog: + * def __get__(self): + * return self.rinfog # <<<<<<<<<<<<<< + * + * property schur: + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self->rinfog)); + __pyx_r = ((PyObject *)__pyx_v_self->rinfog); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":658 + * + * property rinfog: + * def __get__(self): # <<<<<<<<<<<<<< + * return self.rinfog + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":662 + * + * property schur: + * def __get__(self): return self.params.schur # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.schur = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.schur)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 662; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":663 + * property schur: + * def __get__(self): return self.params.schur + * def __set__(self, long value): self.params.schur = value # <<<<<<<<<<<<<< + * + * property wk_user: + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 663; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.schur.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.schur = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":666 + * + * property wk_user: + * def __get__(self): return self.params.wk_user # <<<<<<<<<<<<<< + * def __set__(self, long value): self.params.wk_user = value + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user___get__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user___get__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_long(((long)__pyx_v_self->params.wk_user)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 666; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.wk_user.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":667 + * property wk_user: + * def __get__(self): return self.params.wk_user + * def __set__(self, long value): self.params.wk_user = value # <<<<<<<<<<<<<< + * + * # MUMPS CALL + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ +static int __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { + long __pyx_v_value; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + assert(__pyx_arg_value); { + __pyx_v_value = __Pyx_PyInt_As_long(__pyx_arg_value); if (unlikely((__pyx_v_value == (long)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 667; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.wk_user.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_2__set__(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((long)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_2__set__(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, long __pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __pyx_v_self->params.wk_user = ((DMUMPS_COMPLEX *)__pyx_v_value); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mumps_call(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("mumps_call", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":674 + * Call to Xmumps_c(XMUMPS_STRUC_C). + * """ + * dmumps_c(&self.params) # <<<<<<<<<<<<<< + * + * + */ + dmumps_c((&__pyx_v_self->params)); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":670 + * + * # MUMPS CALL + * cdef mumps_call(self): # <<<<<<<<<<<<<< + * """ + * Call to Xmumps_c(XMUMPS_STRUC_C). + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4set_silent[] = "\n Silence **all* MUMPS output.\n\n See MUMPS documentation.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5set_silent(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set_silent (wrapper)", 0); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4set_silent(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4set_silent(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_silent", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":683 + * See MUMPS documentation. + * """ + * self.icntl[1] = 0 # <<<<<<<<<<<<<< + * self.icntl[2] = 0 + * self.icntl[3] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 1, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 683; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":684 + * """ + * self.icntl[1] = 0 + * self.icntl[2] = 0 # <<<<<<<<<<<<<< + * self.icntl[3] = 0 + * self.icntl[4] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 684; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":685 + * self.icntl[1] = 0 + * self.icntl[2] = 0 + * self.icntl[3] = 0 # <<<<<<<<<<<<<< + * self.icntl[4] = 0 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 3, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 685; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":686 + * self.icntl[2] = 0 + * self.icntl[3] = 0 + * self.icntl[4] = 0 # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 4, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 686; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":677 + * + * + * def set_silent(self): # <<<<<<<<<<<<<< + * """ + * Silence **all* MUMPS output. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.set_silent", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6analyze[] = "\n Performs analysis step of MUMPS.\n\n In the analyis step, MUMPS is able to figure out a reordering for the \n given matrix. It does so if `ordering` is set to 'auto'.\n If not MUMPS will use the provided ordering.\n MUMPS statistics for the analysis are available in `analysis_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7analyze(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("analyze (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,0}; + PyObject* values[1] = {0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "analyze") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("analyze", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 689; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6analyze(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), __pyx_v_ordering); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6analyze(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_ordering) { + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("analyze", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + __pyx_t_1 = (__pyx_v_self->analyzed != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":705 + * """ + * if self.analyzed: + * return # <<<<<<<<<<<<<< + * + * self.icntl[7] = orderings[ordering] + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":704 + * 'auto'. + * """ + * if self.analyzed: # <<<<<<<<<<<<<< + * return + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":707 + * return + * + * self.icntl[7] = orderings[ordering] # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.params.job = 1 # analyse + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_orderings); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyObject_GetItem(__pyx_t_2, __pyx_v_ordering); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 7, __pyx_t_3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 707; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":708 + * + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.params.job = 1 # analyse + * self.mumps_call() + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (__pyx_t_2) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 708; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_t1 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":709 + * self.icntl[7] = orderings[ordering] + * t1 = time.clock() + * self.params.job = 1 # analyse # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_v_self->params.job = 1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":710 + * t1 = time.clock() + * self.params.job = 1 # analyse + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_3 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 710; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":711 + * self.params.job = 1 # analyse + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * if self.infog[1] < 0: + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_4) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 711; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_t2 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 713; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":714 + * + * if self.infog[1] < 0: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * + * self.analyzed = True + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_5 = PyTuple_New(1+1); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); __pyx_t_4 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_5, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 714; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":713 + * t2 = time.clock() + * + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * raise MUMPSError(self.infog) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":716 + * raise MUMPSError(self.infog) + * + * self.analyzed = True # <<<<<<<<<<<<<< + * + * # self.analysis_stats = AnalysisStatistics(self.params, + */ + __pyx_v_self->analyzed = 1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":689 + * + * + * def analyze(self, ordering='auto'): # <<<<<<<<<<<<<< + * """ + * Performs analysis step of MUMPS. + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.analyze", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8factorize[] = "\n Perform the LU factorization of the matrix (or LDL' if the matrix\n is symmetric).\n\n This factorization can then later be used to solve a linear system\n with `solve`. Statistical data of the factorization is stored in\n `factor_stats`.\n\n Args:\n ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' }\n ordering to use in the factorization. The availability of a\n particular ordering depends on the MUMPS installation. Default is\n 'auto'.\n pivot_tol: number in the range [0, 1]\n pivoting threshold. Pivoting is typically limited in sparse\n solvers, as too much pivoting destroys sparsity. 1.0 means full\n pivoting, whereas 0.0 means no pivoting. Default is 0.01.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9factorize(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_ordering = 0; + PyObject *__pyx_v_pivot_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("factorize (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ordering,&__pyx_n_s_pivot_tol,0}; + PyObject* values[2] = {0,0}; + values[0] = ((PyObject *)__pyx_n_s_auto); + values[1] = ((PyObject *)__pyx_float_0_01); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_ordering); + if (value) { values[0] = value; kw_args--; } + } + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_pivot_tol); + if (value) { values[1] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "factorize") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_ordering = values[0]; + __pyx_v_pivot_tol = values[1]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("factorize", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 721; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8factorize(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), __pyx_v_ordering, __pyx_v_pivot_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8factorize(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_ordering, PyObject *__pyx_v_pivot_tol) { + int __pyx_v_done; + CYTHON_UNUSED PyObject *__pyx_v_t1 = NULL; + CYTHON_UNUSED PyObject *__pyx_v_t2 = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("factorize", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + __pyx_t_1 = ((!(__pyx_v_self->analyzed != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":744 + * # Analysis phase must be done before factorization + * if not self.analyzed : + * self.analyze(ordering=ordering) # <<<<<<<<<<<<<< + * + * self.icntl[22] = 1 if self.out_of_core else 1 + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_analyze); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyDict_New(); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_ordering, __pyx_v_ordering) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 744; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":743 + * + * # Analysis phase must be done before factorization + * if not self.analyzed : # <<<<<<<<<<<<<< + * self.analyze(ordering=ordering) + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":746 + * self.analyze(ordering=ordering) + * + * self.icntl[22] = 1 if self.out_of_core else 1 # <<<<<<<<<<<<<< + * self.cntl[1] = pivot_tol + * self.params.job = 2 + */ + if ((__pyx_v_self->out_of_core != 0)) { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_4 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 22, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 746; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":747 + * + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol # <<<<<<<<<<<<<< + * self.params.job = 2 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 1, __pyx_v_pivot_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 747; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":748 + * self.icntl[22] = 1 if self.out_of_core else 1 + * self.cntl[1] = pivot_tol + * self.params.job = 2 # <<<<<<<<<<<<<< + * + * done = False + */ + __pyx_v_self->params.job = 2; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":750 + * self.params.job = 2 + * + * done = False # <<<<<<<<<<<<<< + * while not done: + * t1 = time.clock() + */ + __pyx_v_done = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":751 + * + * done = False + * while not done: # <<<<<<<<<<<<<< + * t1 = time.clock() + * self.mumps_call() + */ + while (1) { + __pyx_t_1 = ((!(__pyx_v_done != 0)) != 0); + if (!__pyx_t_1) break; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":752 + * done = False + * while not done: + * t1 = time.clock() # <<<<<<<<<<<<<< + * self.mumps_call() + * t2 = time.clock() + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_clock); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + if (likely(__pyx_t_3)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_2, function); + } + } + if (__pyx_t_3) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 752; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF_SET(__pyx_v_t1, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":753 + * while not done: + * t1 = time.clock() + * self.mumps_call() # <<<<<<<<<<<<<< + * t2 = time.clock() + * + */ + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 753; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":754 + * t1 = time.clock() + * self.mumps_call() + * t2 = time.clock() # <<<<<<<<<<<<<< + * + * # error -8, -9 (not enough allocated memory) is treated + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_time); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_clock); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __pyx_t_4 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 754; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_t2, __pyx_t_4); + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + __pyx_t_4 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_t_4, __pyx_int_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 758; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->infog), 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_8, -8L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_5) { + } else { + __pyx_t_1 = __pyx_t_5; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_neg_9, -9L, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 759; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_1 = __pyx_t_5; + __pyx_L8_bool_binop_done:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":761 + * if self.infog[1] in (-8, -9): + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 # <<<<<<<<<<<<<< + * else: + * raise MUMPSError(self.infog) + */ + __pyx_t_3 = __Pyx_GetItemInt(((PyObject *)__pyx_v_self->icntl), 14, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyNumber_Multiply(__pyx_t_3, __pyx_int_2); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 14, __pyx_t_4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 761; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":759 + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: + * if self.infog[1] in (-8, -9): # <<<<<<<<<<<<<< + * # double the additional memory + * self.icntl[14] = self.icntl[14]*2 + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":763 + * self.icntl[14] = self.icntl[14]*2 + * else: + * raise MUMPSError(self.infog) # <<<<<<<<<<<<<< + * else: + * done = True + */ + /*else*/ { + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_MUMPSError); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (!__pyx_t_2) { + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_self->infog)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_2); __pyx_t_2 = NULL; + __Pyx_INCREF(((PyObject *)__pyx_v_self->infog)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self->infog)); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, ((PyObject *)__pyx_v_self->infog)); + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 763; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":758 + * # error -8, -9 (not enough allocated memory) is treated + * # specially, by increasing the memory relaxation parameter + * if self.infog[1] < 0: # <<<<<<<<<<<<<< + * if self.infog[1] in (-8, -9): + * # double the additional memory + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":765 + * raise MUMPSError(self.infog) + * else: + * done = True # <<<<<<<<<<<<<< + * + * self.factorized = True + */ + /*else*/ { + __pyx_v_done = 1; + } + __pyx_L6:; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":767 + * done = True + * + * self.factorized = True # <<<<<<<<<<<<<< + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + */ + __pyx_v_self->factorized = 1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":721 + * # t2 - t1) + * + * def factorize(self, ordering='auto', pivot_tol=0.01): # <<<<<<<<<<<<<< + * """ + * Perform the LU factorization of the matrix (or LDL' if the matrix + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.factorize", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_t1); + __Pyx_XDECREF(__pyx_v_t2); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, DMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_solve_dense(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, DMUMPS_COMPLEX *__pyx_v_rhs, MUMPS_INT __pyx_v_rhs_length, MUMPS_INT __pyx_v_nrhs) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_dense", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":782 + * MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + * """ + * self.params.nrhs = nrhs # <<<<<<<<<<<<<< + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + */ + __pyx_v_self->params.nrhs = ((MUMPS_INT)__pyx_v_nrhs); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":783 + * """ + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length # <<<<<<<<<<<<<< + * self.params.rhs = rhs + * self.params.job = 3 # solve + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_rhs_length); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":784 + * self.params.nrhs = nrhs + * self.params.lrhs = rhs_length + * self.params.rhs = rhs # <<<<<<<<<<<<<< + * self.params.job = 3 # solve + * self.mumps_call() + */ + __pyx_v_self->params.rhs = ((DMUMPS_COMPLEX *)__pyx_v_rhs); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":785 + * self.params.lrhs = rhs_length + * self.params.rhs = rhs + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":786 + * self.params.rhs = rhs + * self.params.job = 3 # solve + * self.mumps_call() # <<<<<<<<<<<<<< + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 786; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":770 + * # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + * + * cdef solve_dense(self, DMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): # <<<<<<<<<<<<<< + * """ + * Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.solve_dense", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * DMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * DMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + +static PyObject *__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_solve_sparse(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, MUMPS_INT *__pyx_v_rhs_col_ptr, MUMPS_INT *__pyx_v_rhs_row_ind, DMUMPS_COMPLEX *__pyx_v_rhs_val, MUMPS_INT __pyx_v_rhs_nnz, MUMPS_INT __pyx_v_nrhs, DMUMPS_COMPLEX *__pyx_v_x, MUMPS_INT __pyx_v_x_length) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve_sparse", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":807 + * + * """ + * self.params.nz_rhs = rhs_nnz # <<<<<<<<<<<<<< + * self.params.nrhs = nrhs # nrhs -1 ? + * + */ + __pyx_v_self->params.nz_rhs = __pyx_v_rhs_nnz; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":808 + * """ + * self.params.nz_rhs = rhs_nnz + * self.params.nrhs = nrhs # nrhs -1 ? # <<<<<<<<<<<<<< + * + * self.params.rhs_sparse = rhs_val + */ + __pyx_v_self->params.nrhs = __pyx_v_nrhs; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":810 + * self.params.nrhs = nrhs # nrhs -1 ? + * + * self.params.rhs_sparse = rhs_val # <<<<<<<<<<<<<< + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr + */ + __pyx_v_self->params.rhs_sparse = ((DMUMPS_COMPLEX *)__pyx_v_rhs_val); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":811 + * + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind # <<<<<<<<<<<<<< + * self.params.irhs_ptr = rhs_col_ptr + * + */ + __pyx_v_self->params.irhs_sparse = ((MUMPS_INT *)__pyx_v_rhs_row_ind); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":812 + * self.params.rhs_sparse = rhs_val + * self.params.irhs_sparse = rhs_row_ind + * self.params.irhs_ptr = rhs_col_ptr # <<<<<<<<<<<<<< + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + */ + __pyx_v_self->params.irhs_ptr = ((MUMPS_INT *)__pyx_v_rhs_col_ptr); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":815 + * + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length # <<<<<<<<<<<<<< + * self.params.rhs = x + * + */ + __pyx_v_self->params.lrhs = ((MUMPS_INT)__pyx_v_x_length); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":816 + * # MUMPS places the solution(s) of the linear system in its dense rhs... + * self.params.lrhs = x_length + * self.params.rhs = x # <<<<<<<<<<<<<< + * + * self.params.job = 3 # solve + */ + __pyx_v_self->params.rhs = ((DMUMPS_COMPLEX *)__pyx_v_x); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":818 + * self.params.rhs = x + * + * self.params.job = 3 # solve # <<<<<<<<<<<<<< + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() + */ + __pyx_v_self->params.job = 3; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":819 + * + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse # <<<<<<<<<<<<<< + * self.mumps_call() + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 20, __pyx_int_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 819; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":820 + * self.params.job = 3 # solve + * self.icntl[20] = 1 # tell solver rhs is sparse + * self.mumps_call() # <<<<<<<<<<<<<< + * + * def solve(self, **kwargs): + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->mumps_call(__pyx_v_self); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 820; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":788 + * self.mumps_call() + * + * cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, # <<<<<<<<<<<<<< + * DMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + * DMUMPS_COMPLEX * x, MUMPS_INT x_length): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.solve_sparse", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10solve[] = "\n\n Args:\n rhs: dense NumPy array (matrix or vector).\n rhs_col_ptr, rhs_row_ind, rhs_val: sparse NumPy CSC arrays (matrix or vector).\n transpose_solve : ``True`` or ``False`` whether to solve A * x = rhs or A^T * x = rhs. Default is ``False``\n\n Returns:\n Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11solve(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_kwargs = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("solve (wrapper)", 0); + if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { + __Pyx_RaiseArgtupleInvalid("solve", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return NULL;} + if (__pyx_kwds && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "solve", 1))) return NULL; + __pyx_v_kwargs = (__pyx_kwds) ? PyDict_Copy(__pyx_kwds) : PyDict_New(); if (unlikely(!__pyx_v_kwargs)) return NULL; + __Pyx_GOTREF(__pyx_v_kwargs); + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10solve(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), __pyx_v_kwargs); + + /* function exit code */ + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value); /* proto */ + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5solve_genexpr(PyObject *__pyx_self) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *)__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_outer_scope = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *) __pyx_self; + __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_outer_scope)); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_outer_scope); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5solve_2generator, (PyObject *) __pyx_cur_scope, __pyx_n_s_genexpr, __pyx_n_s_solve_locals_genexpr); if (unlikely(!gen)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.solve.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5solve_2generator(__pyx_CoroutineObject *__pyx_generator, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("None", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_1 = __pyx_tuple__3; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= 3) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_arg); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_arg, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + if (unlikely(!__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs)) { __Pyx_RaiseClosureNameError("kwargs"); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} } + if (unlikely(__pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_cur_scope->__pyx_v_arg, __pyx_cur_scope->__pyx_outer_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); + if (__pyx_t_5) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + } + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10solve(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_kwargs) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *__pyx_cur_scope; + PyObject *__pyx_v_transpose_solve = NULL; + MUMPS_INT __pyx_v_nrhs; + PyObject *__pyx_v_rhs = NULL; + PyObject *__pyx_v_rhs_shape = NULL; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_v_rhs_col_ptr = NULL; + PyObject *__pyx_v_rhs_row_ind = NULL; + PyObject *__pyx_v_rhs_val = NULL; + MUMPS_INT __pyx_v_x_length; + PyObject *__pyx_v_rhs_nnz = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + MUMPS_INT __pyx_t_8; + MUMPS_INT __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("solve", 0); + __pyx_cur_scope = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *)__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve, __pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __Pyx_RefNannyFinishContext(); + return NULL; + } + __Pyx_GOTREF(__pyx_cur_scope); + __pyx_cur_scope->__pyx_v_kwargs = __pyx_v_kwargs; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_kwargs); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_kwargs); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + __pyx_t_1 = ((!(__pyx_v_self->factorized != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":834 + * """ + * if not self.factorized: + * self.factorize() # <<<<<<<<<<<<<< + * + * transpose_solve = kwargs.get('transpose_solve', False) + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_factorize); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + if (__pyx_t_4) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":833 + * Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + * """ + * if not self.factorized: # <<<<<<<<<<<<<< + * self.factorize() + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":836 + * self.factorize() + * + * transpose_solve = kwargs.get('transpose_solve', False) # <<<<<<<<<<<<<< + * self.icntl[9] = 2 if transpose_solve else 1 + * + */ + __pyx_t_2 = __Pyx_PyDict_GetItemDefault(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_transpose_solve, Py_False); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_transpose_solve = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":837 + * + * transpose_solve = kwargs.get('transpose_solve', False) + * self.icntl[9] = 2 if transpose_solve else 1 # <<<<<<<<<<<<<< + * + * cdef: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_transpose_solve); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__pyx_t_1) { + __Pyx_INCREF(__pyx_int_2); + __pyx_t_2 = __pyx_int_2; + } else { + __Pyx_INCREF(__pyx_int_1); + __pyx_t_2 = __pyx_int_1; + } + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 9, __pyx_t_2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + __pyx_t_1 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_rhs, __pyx_cur_scope->__pyx_v_kwargs, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 843; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_5 = (__pyx_t_1 != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":844 + * # rhs can be dense or sparse + * if 'rhs' in kwargs: + * rhs = kwargs['rhs'] # <<<<<<<<<<<<<< + * + * if not cnp.PyArray_Check(rhs): + */ + __pyx_t_2 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_5 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":846 + * rhs = kwargs['rhs'] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":850 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 850; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 852; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":855 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # create x + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 855; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":853 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":852 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":858 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs + */ + __pyx_t_2 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + } + } + if (__pyx_t_7) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } else { + __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_6); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GOTREF(__pyx_t_3); + } else { + __pyx_t_7 = PyTuple_New(1+1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0+1, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 858; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":862 + * # test number of columns in rhs + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * nrhs = rhs_shape[1] + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":861 + * + * # test number of columns in rhs + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L7; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":864 + * nrhs = 1 + * else: + * nrhs = rhs_shape[1] # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 864; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = ((MUMPS_INT)__pyx_t_8); + } + __pyx_L7:; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":866 + * nrhs = rhs_shape[1] + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_4 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((DMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_9, __pyx_v_nrhs); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 866; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":843 + * + * # rhs can be dense or sparse + * if 'rhs' in kwargs: # <<<<<<<<<<<<<< + * rhs = kwargs['rhs'] + * + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_t_4 = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5solve_genexpr(((PyObject*)__pyx_cur_scope)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_Generator_Next(__pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_5 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_5) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":870 + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] # <<<<<<<<<<<<<< + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_col_ptr); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 870; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_col_ptr = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":871 + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] # <<<<<<<<<<<<<< + * rhs_val = kwargs['rhs_val'] + * + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_row_ind); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 871; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_row_ind = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":872 + * rhs_col_ptr = kwargs['rhs_col_ptr'] + * rhs_row_ind = kwargs['rhs_row_ind'] + * rhs_val = kwargs['rhs_val'] # <<<<<<<<<<<<<< + * + * # fortran indices, done internally in C: no efficiency lost + */ + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_cur_scope->__pyx_v_kwargs, __pyx_n_s_rhs_val); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 872; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_rhs_val = __pyx_t_3; + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":875 + * + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 # <<<<<<<<<<<<<< + * rhs_row_ind += 1 + * + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_col_ptr, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 875; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_col_ptr, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":876 + * # fortran indices, done internally in C: no efficiency lost + * rhs_col_ptr += 1 + * rhs_row_ind += 1 # <<<<<<<<<<<<<< + * + * nrhs = rhs_col_ptr.size - 1 + */ + __pyx_t_3 = __Pyx_PyInt_AddObjC(__pyx_v_rhs_row_ind, __pyx_int_1, 1, 1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 876; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF_SET(__pyx_v_rhs_row_ind, __pyx_t_3); + __pyx_t_3 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":878 + * rhs_row_ind += 1 + * + * nrhs = rhs_col_ptr.size - 1 # <<<<<<<<<<<<<< + * x_length = self.nrow + * rhs_nnz = rhs_val.size + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_col_ptr, __pyx_n_s_size); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_SubtractObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_4); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 878; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_nrhs = __pyx_t_8; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":879 + * + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow # <<<<<<<<<<<<<< + * rhs_nnz = rhs_val.size + * + */ + __pyx_t_9 = __pyx_v_self->nrow; + __pyx_v_x_length = __pyx_t_9; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":880 + * nrhs = rhs_col_ptr.size - 1 + * x_length = self.nrow + * rhs_nnz = rhs_val.size # <<<<<<<<<<<<<< + * + * x = np.zeros([self.nrow, nrhs], dtype=np.float64) + */ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs_val, __pyx_n_s_size); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 880; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_v_rhs_nnz = __pyx_t_4; + __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":882 + * rhs_nnz = rhs_val.size + * + * x = np.zeros([self.nrow, nrhs], dtype=np.float64) # <<<<<<<<<<<<<< + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + */ + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_zeros); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_nrhs); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = PyList_New(2); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_t_7); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_float64); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_dtype, __pyx_t_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_7, __pyx_t_2); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 882; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_x = __pyx_t_6; + __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.float64) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + if (!(likely(((__pyx_v_rhs_col_ptr) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_col_ptr, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_rhs_row_ind) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_row_ind, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":885 + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), # <<<<<<<<<<<<<< + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + */ + if (!(likely(((__pyx_v_rhs_val) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_rhs_val, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 885; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":886 + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) # <<<<<<<<<<<<<< + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + */ + __pyx_t_9 = __Pyx_PyInt_As_MUMPS_INT(__pyx_v_rhs_nnz); if (unlikely((__pyx_t_9 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 886; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":884 + * x = np.zeros([self.nrow, nrhs], dtype=np.float64) + * + * self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(rhs_val), + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + */ + __pyx_t_6 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->solve_sparse(__pyx_v_self, ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_col_ptr))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_row_ind))), ((DMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_rhs_val))), __pyx_t_9, __pyx_v_nrhs, ((DMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_v_x_length); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 884; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + goto __pyx_L4; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L4:; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":890 + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + * + * return x # <<<<<<<<<<<<<< + * + * def refine(self, rhs, nitref = 3, tol=None): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":822 + * self.mumps_call() + * + * def solve(self, **kwargs): # <<<<<<<<<<<<<< + * """ + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.solve", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_transpose_solve); + __Pyx_XDECREF(__pyx_v_rhs); + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XDECREF(__pyx_v_rhs_col_ptr); + __Pyx_XDECREF(__pyx_v_rhs_row_ind); + __Pyx_XDECREF(__pyx_v_rhs_val); + __Pyx_XDECREF(__pyx_v_rhs_nnz); + __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/mumps_INT32_FLOAT64.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12refine[] = "\n refine(rhs, nitref) performs iterative refinement if necessary\n until the scaled residual norm ||b-Ax||/(1+||b||) falls below the\n threshold 'tol' or until nitref steps are taken.\n Parameters:\n nitref : < 0 : Fixed number of steps of iterative refinement. No stopping criterion is used. \n 0 : No iterative refinement.\n > 0 : Maximum number of steps of iterative refinement. A stopping criterion is used,\n therefore a test for convergence is done at each step of the iterative refinement algorithm.\n Default: 3\n tol : is the stopping criterion for iterative refinement\n\n Make sure you have called `solve()` with the same right-hand\n side rhs before calling `refine()`.\n The residual vector self.residual will be updated to reflect\n the updated approximate solution.\n "; +static PyObject *__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13refine(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_rhs = 0; + PyObject *__pyx_v_nitref = 0; + PyObject *__pyx_v_tol = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("refine (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_rhs,&__pyx_n_s_nitref,&__pyx_n_s_tol,0}; + PyObject* values[3] = {0,0,0}; + values[1] = ((PyObject *)__pyx_int_3); + values[2] = ((PyObject *)Py_None); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_rhs)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nitref); + if (value) { values[1] = value; kw_args--; } + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_tol); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "refine") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_rhs = values[0]; + __pyx_v_nitref = values[1]; + __pyx_v_tol = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("refine", 0, 1, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 892; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12refine(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), __pyx_v_rhs, __pyx_v_nitref, __pyx_v_tol); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12refine(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyObject *__pyx_v_rhs, PyObject *__pyx_v_nitref, PyObject *__pyx_v_tol) { + PyObject *__pyx_v_rhs_shape = NULL; + long __pyx_v_nrhs; + PyObject *__pyx_v_x = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + MUMPS_INT __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("refine", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + __pyx_t_1 = ((!(PyArray_Check(__pyx_v_rhs) != 0)) != 0); + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":913 + * cnp.npy_intp dim[1] + * + * if not cnp.PyArray_Check(rhs): # <<<<<<<<<<<<<< + * raise TypeError('rhs dense arrays must be an NumPy array') + * + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":917 + * + * # check is dimensions are OK + * rhs_shape = rhs.shape # <<<<<<<<<<<<<< + * + * if (rhs_shape[0] != self.nrow): + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_shape); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 917; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_rhs_shape = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 919; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":922 + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) # <<<<<<<<<<<<<< + * + * # test number of columns in rhs. + */ + __pyx_t_4 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyInt_From_MUMPS_INT(__pyx_v_self->nrow); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + __Pyx_INCREF(__pyx_v_rhs_shape); + __Pyx_GIVEREF(__pyx_v_rhs_shape); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_rhs_shape); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_t_2); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 922; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":920 + * + * if (rhs_shape[0] != self.nrow): + * raise ValueError("Right hand side has wrong size" # <<<<<<<<<<<<<< + * "Attempting to solve the linear system, where A is of size (%d, %d) " + * "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 920; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":919 + * rhs_shape = rhs.shape + * + * if (rhs_shape[0] != self.nrow): # <<<<<<<<<<<<<< + * raise ValueError("Right hand side has wrong size" + * "Attempting to solve the linear system, where A is of size (%d, %d) " + */ + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyInt_EqObjC(__pyx_t_3, __pyx_int_1, 1, 0); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_1 < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 926; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_1) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":927 + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: + * nrhs = 1 # <<<<<<<<<<<<<< + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ + */ + __pyx_v_nrhs = 1; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":926 + * # test number of columns in rhs. + * # Only one rhs is allowed when dense rhs is provided + * if rhs.ndim == 1: # <<<<<<<<<<<<<< + * nrhs = 1 + * else: + */ + goto __pyx_L5; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":929 + * nrhs = 1 + * else: + * raise TypeError("Only one dense rhs is allowed for performing an iterative"+ # <<<<<<<<<<<<<< + * "refinement.") + * + */ + /*else*/ { + __pyx_t_2 = PyNumber_Add(__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_kp_s_refinement); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 929; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L5:; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":933 + * + * # create x + * x = np.asfortranarray(rhs.copy()) # <<<<<<<<<<<<<< + * + * self.icntl[10] = nitref + */ + __pyx_t_3 = __Pyx_GetModuleGlobalName(__pyx_n_s_np); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_asfortranarray); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_rhs, __pyx_n_s_copy); if (unlikely(!__pyx_t_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + if (__pyx_t_6) { + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else { + __pyx_t_3 = __Pyx_PyObject_CallNoArg(__pyx_t_5); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = NULL; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + if (!__pyx_t_5) { + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GOTREF(__pyx_t_2); + } else { + __pyx_t_6 = PyTuple_New(1+1); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5); __pyx_t_5 = NULL; + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_6, 0+1, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 933; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_2; + __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":935 + * x = np.asfortranarray(rhs.copy()) + * + * self.icntl[10] = nitref # <<<<<<<<<<<<<< + * if tol is None: + * self.cntl[2] = 0 + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_v_nitref, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 935; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + __pyx_t_1 = (__pyx_v_tol == Py_None); + __pyx_t_7 = (__pyx_t_1 != 0); + if (__pyx_t_7) { + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":937 + * self.icntl[10] = nitref + * if tol is None: + * self.cntl[2] = 0 # <<<<<<<<<<<<<< + * else: + * self.cntl[2] = tol + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 937; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":936 + * + * self.icntl[10] = nitref + * if tol is None: # <<<<<<<<<<<<<< + * self.cntl[2] = 0 + * else: + */ + goto __pyx_L6; + } + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":939 + * self.cntl[2] = 0 + * else: + * self.cntl[2] = tol # <<<<<<<<<<<<<< + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + */ + /*else*/ { + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_v_tol, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 939; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L6:; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":941 + * self.cntl[2] = tol + * + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) # <<<<<<<<<<<<<< + * + * # reset to default values + */ + if (!(likely(((__pyx_v_x) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_x, __pyx_ptype_5numpy_ndarray))))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_t_2 = __Pyx_GetItemInt(__pyx_v_rhs_shape, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(__pyx_t_2 == NULL)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_8 = __Pyx_PyInt_As_MUMPS_INT(__pyx_t_2); if (unlikely((__pyx_t_8 == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = ((struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_vtab)->solve_dense(__pyx_v_self, ((DMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_x))), __pyx_t_8, __pyx_v_nrhs); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 941; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":944 + * + * # reset to default values + * self.icntl[10] = 0 # <<<<<<<<<<<<<< + * self.cntl[2] = -1 + * + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->icntl), 10, __pyx_int_0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 944; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":945 + * # reset to default values + * self.icntl[10] = 0 + * self.cntl[2] = -1 # <<<<<<<<<<<<<< + * + * return x + */ + if (unlikely(__Pyx_SetItemInt(((PyObject *)__pyx_v_self->cntl), 2, __pyx_int_neg_1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 945; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":947 + * self.cntl[2] = -1 + * + * return x # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_x); + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":892 + * return x + * + * def refine(self, rhs, nitref = 3, tol=None): # <<<<<<<<<<<<<< + * """ + * refine(rhs, nitref) performs iterative refinement if necessary + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64.refine", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_rhs_shape); + __Pyx_XDECREF(__pyx_v_x); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__12, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; + if (unlikely(__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_mumps_int_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_mumps_int_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT64.mumps_int_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_mumps_int_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_mumps_int_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Integer version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; + if (unlikely(__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_5__setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array[] = { + {0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_dmumps_real_array = { + 0, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_dmumps_real_array = { + 0, /*mp_length*/ + __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_3__getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array, /*mp_ass_subscript*/ +}; + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT64.dmumps_real_array", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_dmumps_real_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_dmumps_real_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + "\n Internal classes to use x[i] = value and x[i] setters and getters\n\n Real version.\n\n ", /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)o); + p->__pyx_vtab = __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + p->icntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->info = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->infog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + p->cntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfo = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->rinfog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)Py_None); Py_INCREF(Py_None); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + p->solve_stats = Py_None; Py_INCREF(Py_None); + if (unlikely(__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64(PyObject *o) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)o; + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + ++Py_REFCNT(o); + __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3__dealloc__(o); + --Py_REFCNT(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->icntl); + Py_CLEAR(p->info); + Py_CLEAR(p->infog); + Py_CLEAR(p->cntl); + Py_CLEAR(p->rinfo); + Py_CLEAR(p->rinfog); + Py_CLEAR(p->analysis_stats); + Py_CLEAR(p->factorize_stats); + Py_CLEAR(p->solve_stats); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)o; + if (p->icntl) { + e = (*v)(((PyObject*)p->icntl), a); if (e) return e; + } + if (p->info) { + e = (*v)(((PyObject*)p->info), a); if (e) return e; + } + if (p->infog) { + e = (*v)(((PyObject*)p->infog), a); if (e) return e; + } + if (p->cntl) { + e = (*v)(((PyObject*)p->cntl), a); if (e) return e; + } + if (p->rinfo) { + e = (*v)(((PyObject*)p->rinfo), a); if (e) return e; + } + if (p->rinfog) { + e = (*v)(((PyObject*)p->rinfog), a); if (e) return e; + } + if (p->analysis_stats) { + e = (*v)(p->analysis_stats, a); if (e) return e; + } + if (p->factorize_stats) { + e = (*v)(p->factorize_stats, a); if (e) return e; + } + if (p->solve_stats) { + e = (*v)(p->solve_stats, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)o; + tmp = ((PyObject*)p->icntl); + p->icntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->info); + p->info = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->infog); + p->infog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->cntl); + p->cntl = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfo); + p->rinfo = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->rinfog); + p->rinfog = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->analysis_stats); + p->analysis_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->factorize_stats); + p->factorize_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->solve_stats); + p->solve_stats = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_analyzed(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8analyzed_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_factorized(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10factorized_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3sym_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_par(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_par(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3par_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_job(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_job(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3job_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_comm_fortran(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_comm_fortran(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12comm_fortran_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_icntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5icntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_n(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_n(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1n_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_alloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_alloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8nz_alloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_2nz_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3irn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3jcn_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7irn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7jcn_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nelt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nelt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nelt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltvar(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltvar(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6eltvar_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_perm_in(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_perm_in(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7perm_in_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8sym_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_uns_perm(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_uns_perm(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8uns_perm_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11irhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_ptr(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_ptr(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8irhs_ptr_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_isol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_isol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8isol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4nrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4lrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lredrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lredrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7lredrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nz_rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lsol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lsol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lsol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_mloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_mloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_mloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_nloc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_nloc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10schur_nloc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_lld(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_lld(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9schur_lld_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6mblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nblock(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nblock(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6nblock_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nprow(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nprow(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5nprow_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_npcol(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_npcol(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5npcol_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_info(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4info_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_infog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5infog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_deficiency(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_deficiency(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10deficiency_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_pivnul_list(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_pivnul_list(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11pivnul_list_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mapping(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mapping(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7mapping_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_size_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_size_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10size_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_listvar_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_listvar_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13listvar_schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_instance_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_instance_number(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_15instance_number_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_version_number(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_14version_number_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_tmpdir(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_tmpdir(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_tmpdir_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_prefix(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_prefix(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10ooc_prefix_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_write_problem(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_write_problem(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13write_problem_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lwk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lwk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8lwk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_cntl(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4cntl_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_1a_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_elt(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_elt(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5a_elt_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_colsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_colsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6colsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rowsca(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rowsca(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rowsca_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_3rhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_redrhs(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_redrhs(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6redrhs_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs_sparse(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs_sparse(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10rhs_sparse_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sol_loc(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sol_loc(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7sol_loc_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rinfo(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5rinfo_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rinfog(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6rinfog_1__get__(o); +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5schur_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_wk_user(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_1__get__(o); +} + +static int __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_wk_user(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7wk_user_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64[] = { + {"set_silent", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_5set_silent, METH_NOARGS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_4set_silent}, + {"analyze", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_7analyze, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_6analyze}, + {"factorize", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_9factorize, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_8factorize}, + {"solve", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_11solve, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_10solve}, + {"refine", (PyCFunction)__pyx_pw_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_13refine, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_12refine}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64[] = { + {(char *)"analyzed", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_analyzed, 0, 0, 0}, + {(char *)"factorized", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_factorized, 0, 0, 0}, + {(char *)"sym", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym, 0, 0}, + {(char *)"par", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_par, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_par, 0, 0}, + {(char *)"job", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_job, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_job, 0, 0}, + {(char *)"comm_fortran", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_comm_fortran, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_comm_fortran, 0, 0}, + {(char *)"icntl", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_icntl, 0, 0, 0}, + {(char *)"n", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_n, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_n, 0, 0}, + {(char *)"nz_alloc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_alloc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_alloc, 0, 0}, + {(char *)"nz", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz, 0, 0}, + {(char *)"irn", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn, 0, 0}, + {(char *)"jcn", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn, 0, 0}, + {(char *)"nz_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_loc, 0, 0}, + {(char *)"irn_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irn_loc, 0, 0}, + {(char *)"jcn_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_jcn_loc, 0, 0}, + {(char *)"nelt", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nelt, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nelt, 0, 0}, + {(char *)"eltptr", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltptr, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltptr, 0, 0}, + {(char *)"eltvar", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltvar, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_eltvar, 0, 0}, + {(char *)"perm_in", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_perm_in, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_perm_in, 0, 0}, + {(char *)"sym_perm", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym_perm, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sym_perm, 0, 0}, + {(char *)"uns_perm", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_uns_perm, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_uns_perm, 0, 0}, + {(char *)"irhs_sparse", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_sparse, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_sparse, 0, 0}, + {(char *)"irhs_ptr", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_ptr, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_irhs_ptr, 0, 0}, + {(char *)"isol_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_isol_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_isol_loc, 0, 0}, + {(char *)"nrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nrhs, 0, 0}, + {(char *)"lrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lrhs, 0, 0}, + {(char *)"lredrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lredrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lredrhs, 0, 0}, + {(char *)"nz_rhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_rhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nz_rhs, 0, 0}, + {(char *)"lsol_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lsol_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lsol_loc, 0, 0}, + {(char *)"schur_mloc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_mloc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_mloc, 0, 0}, + {(char *)"schur_nloc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_nloc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_nloc, 0, 0}, + {(char *)"schur_lld", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_lld, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur_lld, 0, 0}, + {(char *)"mblock", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mblock, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mblock, 0, 0}, + {(char *)"nblock", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nblock, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nblock, 0, 0}, + {(char *)"nprow", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nprow, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_nprow, 0, 0}, + {(char *)"npcol", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_npcol, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_npcol, 0, 0}, + {(char *)"info", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_info, 0, 0, 0}, + {(char *)"infog", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_infog, 0, 0, 0}, + {(char *)"deficiency", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_deficiency, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_deficiency, 0, 0}, + {(char *)"pivnul_list", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_pivnul_list, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_pivnul_list, 0, 0}, + {(char *)"mapping", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mapping, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mapping, 0, 0}, + {(char *)"size_schur", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_size_schur, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_size_schur, 0, 0}, + {(char *)"listvar_schur", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_listvar_schur, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_listvar_schur, 0, 0}, + {(char *)"instance_number", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_instance_number, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_instance_number, 0, 0}, + {(char *)"version_number", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_version_number, 0, 0, 0}, + {(char *)"ooc_tmpdir", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_tmpdir, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_tmpdir, 0, 0}, + {(char *)"ooc_prefix", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_prefix, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_ooc_prefix, 0, 0}, + {(char *)"write_problem", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_write_problem, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_write_problem, 0, 0}, + {(char *)"lwk_user", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lwk_user, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_lwk_user, 0, 0}, + {(char *)"cntl", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_cntl, 0, 0, 0}, + {(char *)"a", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a, 0, 0}, + {(char *)"a_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_loc, 0, 0}, + {(char *)"a_elt", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_elt, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_a_elt, 0, 0}, + {(char *)"colsca", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_colsca, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_colsca, 0, 0}, + {(char *)"rowsca", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rowsca, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rowsca, 0, 0}, + {(char *)"rhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs, 0, 0}, + {(char *)"redrhs", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_redrhs, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_redrhs, 0, 0}, + {(char *)"rhs_sparse", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs_sparse, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rhs_sparse, 0, 0}, + {(char *)"sol_loc", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sol_loc, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_sol_loc, 0, 0}, + {(char *)"rinfo", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rinfo, 0, 0, 0}, + {(char *)"rinfog", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_rinfog, 0, 0, 0}, + {(char *)"schur", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_schur, 0, 0}, + {(char *)"wk_user", __pyx_getprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_wk_user, __pyx_setprop_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_wk_user, 0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT64.BaseMUMPSSolver_INT32_FLOAT64", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n Base MUMPS Context.\n\n This version **only** deals with array pointers.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve[8]; +static int __pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve[--__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve(PyObject *o) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_v_kwargs); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve)))) { + __pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve[__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve++] = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *)o; + if (p->__pyx_v_kwargs) { + e = (*v)(p->__pyx_v_kwargs, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *)o; + tmp = ((PyObject*)p->__pyx_v_kwargs); + p->__pyx_v_kwargs = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT64.__pyx_scope_struct__solve", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr[8]; +static int __pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr = 0; + +static PyObject *__pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr)))) { + o = (PyObject*)__pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr[--__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr]; + memset(o, 0, sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr)); + (void) PyObject_INIT(o, t); + PyObject_GC_Track(o); + } else { + o = (*t->tp_alloc)(t, 0); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *)o; + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_outer_scope); + Py_CLEAR(p->__pyx_v_arg); + if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr)))) { + __pyx_freelist_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr[__pyx_freecount_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *)o); + } else { + (*Py_TYPE(o)->tp_free)(o); + } +} + +static int __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *)o; + if (p->__pyx_outer_scope) { + e = (*v)(((PyObject*)p->__pyx_outer_scope), a); if (e) return e; + } + if (p->__pyx_v_arg) { + e = (*v)(p->__pyx_v_arg, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr *)o; + tmp = ((PyObject*)p->__pyx_outer_scope); + p->__pyx_outer_scope = ((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->__pyx_v_arg); + p->__pyx_v_arg = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyTypeObject __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.mumps_INT32_FLOAT64.__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "mumps_INT32_FLOAT64", + __pyx_k_This_is_the_base_class_for_the, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_AnalysisStatistics, __pyx_k_AnalysisStatistics, sizeof(__pyx_k_AnalysisStatistics), 0, 0, 1, 1}, + {&__pyx_n_s_FactorizationStatistics, __pyx_k_FactorizationStatistics, sizeof(__pyx_k_FactorizationStatistics), 0, 0, 1, 1}, + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError, __pyx_k_MUMPSError, sizeof(__pyx_k_MUMPSError), 0, 0, 1, 1}, + {&__pyx_n_s_MUMPSError___init, __pyx_k_MUMPSError___init, sizeof(__pyx_k_MUMPSError___init), 0, 0, 1, 1}, + {&__pyx_kp_s_MUMPS_error, __pyx_k_MUMPS_error, sizeof(__pyx_k_MUMPS_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_failed_with_error, __pyx_k_MUMPS_failed_with_error, sizeof(__pyx_k_MUMPS_failed_with_error), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_1_Fortran_st, __pyx_k_MUMPS_index_must_be_1_Fortran_st, sizeof(__pyx_k_MUMPS_index_must_be_1_Fortran_st), 0, 0, 1, 0}, + {&__pyx_kp_s_MUMPS_index_must_be_d, __pyx_k_MUMPS_index_must_be_d, sizeof(__pyx_k_MUMPS_index_must_be_d), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_numerically_singular, __pyx_k_Matrix_is_numerically_singular, sizeof(__pyx_k_Matrix_is_numerically_singular), 0, 0, 1, 0}, + {&__pyx_kp_s_Matrix_is_singular_in_structure, __pyx_k_Matrix_is_singular_in_structure, sizeof(__pyx_k_Matrix_is_singular_in_structure), 0, 0, 1, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_kp_s_Not_enough_memory, __pyx_k_Not_enough_memory, sizeof(__pyx_k_Not_enough_memory), 0, 0, 1, 0}, + {&__pyx_kp_s_Not_enough_memory_during_analysi, __pyx_k_Not_enough_memory_during_analysi, sizeof(__pyx_k_Not_enough_memory_during_analysi), 0, 0, 1, 0}, + {&__pyx_kp_s_Only_one_dense_rhs_is_allowed_fo, __pyx_k_Only_one_dense_rhs_is_allowed_fo, sizeof(__pyx_k_Only_one_dense_rhs_is_allowed_fo), 0, 0, 1, 0}, + {&__pyx_kp_s_Right_hand_side_has_wrong_sizeAt, __pyx_k_Right_hand_side_has_wrong_sizeAt, sizeof(__pyx_k_Right_hand_side_has_wrong_sizeAt), 0, 0, 1, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_SolveStatistics, __pyx_k_SolveStatistics, sizeof(__pyx_k_SolveStatistics), 0, 0, 1, 1}, + {&__pyx_kp_s_The_authors_of_MUMPS_would_like, __pyx_k_The_authors_of_MUMPS_would_like, sizeof(__pyx_k_The_authors_of_MUMPS_would_like), 0, 0, 1, 0}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_k_Users_syarra_work_VirtualEnvs_n, sizeof(__pyx_k_Users_syarra_work_VirtualEnvs_n), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_amd, __pyx_k_amd, sizeof(__pyx_k_amd), 0, 0, 1, 1}, + {&__pyx_n_s_amf, __pyx_k_amf, sizeof(__pyx_k_amf), 0, 0, 1, 1}, + {&__pyx_n_s_analyze, __pyx_k_analyze, sizeof(__pyx_k_analyze), 0, 0, 1, 1}, + {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, + {&__pyx_n_s_asfortranarray, __pyx_k_asfortranarray, sizeof(__pyx_k_asfortranarray), 0, 0, 1, 1}, + {&__pyx_n_s_auto, __pyx_k_auto, sizeof(__pyx_k_auto), 0, 0, 1, 1}, + {&__pyx_n_s_clock, __pyx_k_clock, sizeof(__pyx_k_clock), 0, 0, 1, 1}, + {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_doc, __pyx_k_doc, sizeof(__pyx_k_doc), 0, 0, 1, 1}, + {&__pyx_n_s_dtype, __pyx_k_dtype, sizeof(__pyx_k_dtype), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_error_messages, __pyx_k_error_messages, sizeof(__pyx_k_error_messages), 0, 0, 1, 1}, + {&__pyx_n_s_factorize, __pyx_k_factorize, sizeof(__pyx_k_factorize), 0, 0, 1, 1}, + {&__pyx_n_s_float64, __pyx_k_float64, sizeof(__pyx_k_float64), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_genexpr, __pyx_k_genexpr, sizeof(__pyx_k_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_infog, __pyx_k_infog, sizeof(__pyx_k_infog), 0, 0, 1, 1}, + {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_metaclass, __pyx_k_metaclass, sizeof(__pyx_k_metaclass), 0, 0, 1, 1}, + {&__pyx_n_s_metis, __pyx_k_metis, sizeof(__pyx_k_metis), 0, 0, 1, 1}, + {&__pyx_n_s_module, __pyx_k_module, sizeof(__pyx_k_module), 0, 0, 1, 1}, + {&__pyx_n_s_msg, __pyx_k_msg, sizeof(__pyx_k_msg), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_mumps_statistics, __pyx_k_mumps_mumps_statistics, sizeof(__pyx_k_mumps_mumps_statistics), 0, 0, 1, 1}, + {&__pyx_n_s_mumps_src_mumps_INT32_FLOAT64, __pyx_k_mumps_src_mumps_INT32_FLOAT64, sizeof(__pyx_k_mumps_src_mumps_INT32_FLOAT64), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_nitref, __pyx_k_nitref, sizeof(__pyx_k_nitref), 0, 0, 1, 1}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_ordering, __pyx_k_ordering, sizeof(__pyx_k_ordering), 0, 0, 1, 1}, + {&__pyx_n_s_ordering_name, __pyx_k_ordering_name, sizeof(__pyx_k_ordering_name), 0, 0, 1, 1}, + {&__pyx_n_s_orderings, __pyx_k_orderings, sizeof(__pyx_k_orderings), 0, 0, 1, 1}, + {&__pyx_n_s_pivot_tol, __pyx_k_pivot_tol, sizeof(__pyx_k_pivot_tol), 0, 0, 1, 1}, + {&__pyx_n_s_pord, __pyx_k_pord, sizeof(__pyx_k_pord), 0, 0, 1, 1}, + {&__pyx_n_s_prepare, __pyx_k_prepare, sizeof(__pyx_k_prepare), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_qamd, __pyx_k_qamd, sizeof(__pyx_k_qamd), 0, 0, 1, 1}, + {&__pyx_n_s_qualname, __pyx_k_qualname, sizeof(__pyx_k_qualname), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_kp_s_refinement, __pyx_k_refinement, sizeof(__pyx_k_refinement), 0, 0, 1, 0}, + {&__pyx_n_s_rhs, __pyx_k_rhs, sizeof(__pyx_k_rhs), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_col_ptr, __pyx_k_rhs_col_ptr, sizeof(__pyx_k_rhs_col_ptr), 0, 0, 1, 1}, + {&__pyx_kp_s_rhs_dense_arrays_must_be_an_NumP, __pyx_k_rhs_dense_arrays_must_be_an_NumP, sizeof(__pyx_k_rhs_dense_arrays_must_be_an_NumP), 0, 0, 1, 0}, + {&__pyx_kp_s_rhs_not_given_in_the_right_forma, __pyx_k_rhs_not_given_in_the_right_forma, sizeof(__pyx_k_rhs_not_given_in_the_right_forma), 0, 0, 1, 0}, + {&__pyx_n_s_rhs_row_ind, __pyx_k_rhs_row_ind, sizeof(__pyx_k_rhs_row_ind), 0, 0, 1, 1}, + {&__pyx_n_s_rhs_val, __pyx_k_rhs_val, sizeof(__pyx_k_rhs_val), 0, 0, 1, 1}, + {&__pyx_n_s_scotch, __pyx_k_scotch, sizeof(__pyx_k_scotch), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, + {&__pyx_n_s_set_silent, __pyx_k_set_silent, sizeof(__pyx_k_set_silent), 0, 0, 1, 1}, + {&__pyx_n_s_shape, __pyx_k_shape, sizeof(__pyx_k_shape), 0, 0, 1, 1}, + {&__pyx_n_s_size, __pyx_k_size, sizeof(__pyx_k_size), 0, 0, 1, 1}, + {&__pyx_n_s_solve_locals_genexpr, __pyx_k_solve_locals_genexpr, sizeof(__pyx_k_solve_locals_genexpr), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, + {&__pyx_n_s_time, __pyx_k_time, sizeof(__pyx_k_time), 0, 0, 1, 1}, + {&__pyx_n_s_tol, __pyx_k_tol, sizeof(__pyx_k_tol), 0, 0, 1, 1}, + {&__pyx_n_s_transpose_solve, __pyx_k_transpose_solve, sizeof(__pyx_k_transpose_solve), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_kp_s_user_defined, __pyx_k_user_defined, sizeof(__pyx_k_user_defined), 0, 0, 1, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {&__pyx_n_s_zeros, __pyx_k_zeros, sizeof(__pyx_k_zeros), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 853; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":265 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 265; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":294 + * def __getitem__(self, key): + * if key < 1: + * raise IndexError('MUMPS index must be >= 1 (Fortran style)') # <<<<<<<<<<<<<< + * if key > self.ub: + * raise IndexError('MUMPS index must be <= %d' % self.ub) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_MUMPS_index_must_be_1_Fortran_st); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 294; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":868 + * self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + * + * elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : # <<<<<<<<<<<<<< + * + * rhs_col_ptr = kwargs['rhs_col_ptr'] + */ + __pyx_tuple__3 = PyTuple_Pack(3, __pyx_n_s_rhs_col_ptr, __pyx_n_s_rhs_row_ind, __pyx_n_s_rhs_val); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":847 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 847; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":888 + * rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + * else: + * raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') # <<<<<<<<<<<<<< + * + * return x + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_rhs_not_given_in_the_right_forma); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 888; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":914 + * + * if not cnp.PyArray_Check(rhs): + * raise TypeError('rhs dense arrays must be an NumPy array') # <<<<<<<<<<<<<< + * + * # check is dimensions are OK + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_rhs_dense_arrays_must_be_an_NumP); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 914; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple__7)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__8)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__9)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__10)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__11)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__12)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_tuple__13 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_infog, __pyx_n_s_msg); if (unlikely(!__pyx_tuple__13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, 0, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__13, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_Users_syarra_work_VirtualEnvs_n, __pyx_n_s_init, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_float_0_01 = PyFloat_FromDouble(0.01); if (unlikely(!__pyx_float_0_01)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_5 = PyInt_FromLong(-5); if (unlikely(!__pyx_int_neg_5)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_6 = PyInt_FromLong(-6); if (unlikely(!__pyx_int_neg_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_7 = PyInt_FromLong(-7); if (unlikely(!__pyx_int_neg_7)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_8 = PyInt_FromLong(-8); if (unlikely(!__pyx_int_neg_8)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_9 = PyInt_FromLong(-9); if (unlikely(!__pyx_int_neg_9)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_10 = PyInt_FromLong(-10); if (unlikely(!__pyx_int_neg_10)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_11 = PyInt_FromLong(-11); if (unlikely(!__pyx_int_neg_11)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_12 = PyInt_FromLong(-12); if (unlikely(!__pyx_int_neg_12)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_13 = PyInt_FromLong(-13); if (unlikely(!__pyx_int_neg_13)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initmumps_INT32_FLOAT64(void); /*proto*/ +PyMODINIT_FUNC initmumps_INT32_FLOAT64(void) +#else +PyMODINIT_FUNC PyInit_mumps_INT32_FLOAT64(void); /*proto*/ +PyMODINIT_FUNC PyInit_mumps_INT32_FLOAT64(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_mumps_INT32_FLOAT64(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("mumps_INT32_FLOAT64", __pyx_methods, __pyx_k_This_is_the_base_class_for_the, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__mumps_INT32_FLOAT64) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.mumps_INT32_FLOAT64")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.mumps_INT32_FLOAT64", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + if (__Pyx_ExportFunction("c_to_fortran_index_array", (void (*)(void))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Type init code ---*/ + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array = &__pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array.tp_dict, __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "mumps_int_array", (PyObject *)&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 245; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array = &__pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array.get_array = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *, DMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array *__pyx_optional_args))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array.tp_dict, __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "dmumps_real_array", (PyObject *)&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 274; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 = &__pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.get_data_pointers = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, MUMPS_INT *, MUMPS_INT *, DMUMPS_COMPLEX *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_get_data_pointers; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.initialize_mumps_struct = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, PyObject *, PyObject *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_initialize_mumps_struct; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.mumps_call = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_mumps_call; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.set_centralized_assembled_matrix = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_set_centralized_assembled_matrix; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.solve_dense = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, DMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_solve_dense; + __pyx_vtable_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.solve_sparse = (PyObject *(*)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, MUMPS_INT *, MUMPS_INT *, DMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, DMUMPS_COMPLEX *, MUMPS_INT))__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_29BaseMUMPSSolver_INT32_FLOAT64_solve_sparse; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64.tp_dict, __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "BaseMUMPSSolver_INT32_FLOAT64", (PyObject *)&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 313; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 822; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve.tp_print = 0; + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct__solve; + if (PyType_Ready(&__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 868; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr.tp_print = 0; + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr = &__pyx_type_5mumps_3src_19mumps_INT32_FLOAT64___pyx_scope_struct_1_genexpr; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_4bool_bool = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "bool", sizeof(PyBoolObject), 0); if (unlikely(!__pyx_ptype_7cpython_4bool_bool)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 8; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_7cpython_7complex_complex = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "complex", sizeof(PyComplexObject), 0); if (unlikely(!__pyx_ptype_7cpython_7complex_complex)) {__pyx_filename = __pyx_f[4]; __pyx_lineno = 15; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":88 + * """ + * + * from mumps.mumps_statistics import AnalysisStatistics, FactorizationStatistics, SolveStatistics # <<<<<<<<<<<<<< + * + * from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free + */ + __pyx_t_1 = PyList_New(3); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_AnalysisStatistics); + __Pyx_GIVEREF(__pyx_n_s_AnalysisStatistics); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_AnalysisStatistics); + __Pyx_INCREF(__pyx_n_s_FactorizationStatistics); + __Pyx_GIVEREF(__pyx_n_s_FactorizationStatistics); + PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_FactorizationStatistics); + __Pyx_INCREF(__pyx_n_s_SolveStatistics); + __Pyx_GIVEREF(__pyx_n_s_SolveStatistics); + PyList_SET_ITEM(__pyx_t_1, 2, __pyx_n_s_SolveStatistics); + __pyx_t_2 = __Pyx_Import(__pyx_n_s_mumps_mumps_statistics, __pyx_t_1, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_AnalysisStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_AnalysisStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_FactorizationStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FactorizationStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_SolveStatistics); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_SolveStatistics, __pyx_t_1) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 88; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":96 + * from libc.string cimport strncpy + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 96; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":99 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * import time + */ + import_array(); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":101 + * cnp.import_array() + * + * import time # <<<<<<<<<<<<<< + * + * cdef extern from "mumps_c_types.h": + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_time, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_time, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 101; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":214 + * + * # MUMPS possible ordering methods + * orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, # <<<<<<<<<<<<<< + * 'qamd' : 6, 'auto' : 7 } + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amd, __pyx_int_0) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_amf, __pyx_int_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_scotch, __pyx_int_3) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_pord, __pyx_int_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_metis, __pyx_int_5) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_qamd, __pyx_int_6) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_n_s_auto, __pyx_int_7) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_orderings, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 214; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":217 + * 'qamd' : 6, 'auto' : 7 } + * + * ordering_name = [ 'amd', 'user-defined', 'amf', # <<<<<<<<<<<<<< + * 'scotch', 'pord', 'metis', 'qamd'] + * + */ + __pyx_t_2 = PyList_New(7); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_n_s_amd); + __Pyx_GIVEREF(__pyx_n_s_amd); + PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_amd); + __Pyx_INCREF(__pyx_kp_s_user_defined); + __Pyx_GIVEREF(__pyx_kp_s_user_defined); + PyList_SET_ITEM(__pyx_t_2, 1, __pyx_kp_s_user_defined); + __Pyx_INCREF(__pyx_n_s_amf); + __Pyx_GIVEREF(__pyx_n_s_amf); + PyList_SET_ITEM(__pyx_t_2, 2, __pyx_n_s_amf); + __Pyx_INCREF(__pyx_n_s_scotch); + __Pyx_GIVEREF(__pyx_n_s_scotch); + PyList_SET_ITEM(__pyx_t_2, 3, __pyx_n_s_scotch); + __Pyx_INCREF(__pyx_n_s_pord); + __Pyx_GIVEREF(__pyx_n_s_pord); + PyList_SET_ITEM(__pyx_t_2, 4, __pyx_n_s_pord); + __Pyx_INCREF(__pyx_n_s_metis); + __Pyx_GIVEREF(__pyx_n_s_metis); + PyList_SET_ITEM(__pyx_t_2, 5, __pyx_n_s_metis); + __Pyx_INCREF(__pyx_n_s_qamd); + __Pyx_GIVEREF(__pyx_n_s_qamd); + PyList_SET_ITEM(__pyx_t_2, 6, __pyx_n_s_qamd); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ordering_name, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 217; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":223 + * # TODO: decouple + * error_messages = { + * -5 : "Not enough memory during analysis phase", # <<<<<<<<<<<<<< + * -6 : "Matrix is singular in structure", + * -7 : "Not enough memory during analysis phase", + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_5, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_6, __pyx_kp_s_Matrix_is_singular_in_structure) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_7, __pyx_kp_s_Not_enough_memory_during_analysi) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_10, __pyx_kp_s_Matrix_is_numerically_singular) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_11, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_12, __pyx_kp_s_The_authors_of_MUMPS_would_like) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_t_2, __pyx_int_neg_13, __pyx_kp_s_Not_enough_memory) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 223; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyDict_SetItem(__pyx_d, __pyx_n_s_error_messages, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_builtin_RuntimeError); + __Pyx_GIVEREF(__pyx_builtin_RuntimeError); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_builtin_RuntimeError); + __pyx_t_1 = __Pyx_CalculateMetaclass(NULL, __pyx_t_2); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_Py3MetaclassPrepare(__pyx_t_1, __pyx_t_2, __pyx_n_s_MUMPSError, __pyx_n_s_MUMPSError, (PyObject *) NULL, __pyx_n_s_mumps_src_mumps_INT32_FLOAT64, (PyObject *) NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":234 + * + * class MUMPSError(RuntimeError): + * def __init__(self, infog): # <<<<<<<<<<<<<< + * self.error = infog[1] + * if self.error in error_messages: + */ + __pyx_t_4 = __Pyx_CyFunction_NewEx(&__pyx_mdef_5mumps_3src_19mumps_INT32_FLOAT64_10MUMPSError_1__init__, 0, __pyx_n_s_MUMPSError___init, NULL, __pyx_n_s_mumps_src_mumps_INT32_FLOAT64, __pyx_d, ((PyObject *)__pyx_codeobj__14)); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyObject_SetItem(__pyx_t_3, __pyx_n_s_init, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 234; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":233 + * + * + * class MUMPSError(RuntimeError): # <<<<<<<<<<<<<< + * def __init__(self, infog): + * self.error = infog[1] + */ + __pyx_t_4 = __Pyx_Py3ClassCreate(__pyx_t_1, __pyx_n_s_MUMPSError, __pyx_t_2, __pyx_t_3, NULL, 0, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_MUMPSError, __pyx_t_4) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 233; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/mumps_INT32_FLOAT64.pyx":1 + * """ # <<<<<<<<<<<<<< + * This is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home) + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.mumps_INT32_FLOAT64", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.mumps_INT32_FLOAT64"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyList_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (wraparound & unlikely(i < 0)) i += PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((0 <= i) & (i < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return NULL; + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +static CYTHON_INLINE PyObject *__Pyx_GetModuleGlobalName(PyObject *name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON + result = PyDict_GetItem(__pyx_d, name); + if (likely(result)) { + Py_INCREF(result); + } else { +#else + result = PyObject_GetItem(__pyx_d, name); + if (!result) { + PyErr_Clear(); +#endif + result = __Pyx_GetBuiltinName(name); + } + return result; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +static CYTHON_INLINE int __Pyx_CheckKeywordStrings( + PyObject *kwdict, + const char* function_name, + int kw_allowed) +{ + PyObject* key = 0; + Py_ssize_t pos = 0; +#if CYTHON_COMPILING_IN_PYPY + if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + while (PyDict_Next(kwdict, &pos, &key, 0)) { + #if PY_MAJOR_VERSION < 3 + if (unlikely(!PyString_CheckExact(key)) && unlikely(!PyString_Check(key))) + #endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; + } + if ((!kw_allowed) && unlikely(key)) + goto invalid_keyword; + return 1; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + return 0; +#endif +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; +} + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_SubtractObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a - b); + if (likely((x^a) >= 0 || (x^~b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_subtract(op1, op2); + } + } + x = a - b; + return PyLong_FromLong(x); + long_long: + llx = lla - llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("subtract", return NULL) + result = ((double)a) - (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceSubtract : PyNumber_Subtract)(op1, op2); +} +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { +#ifdef __Pyx_CyFunction_USED + if (likely(PyCFunction_Check(func) || PyObject_TypeCheck(func, __pyx_CyFunctionType))) { +#else + if (likely(PyCFunction_Check(func))) { +#endif + if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { + return __Pyx_PyObject_CallMethO(func, NULL); + } + } + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); +} +#endif + +static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, + CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, + int full_traceback, CYTHON_UNUSED int nogil) { + PyObject *old_exc, *old_val, *old_tb; + PyObject *ctx; +#ifdef WITH_THREAD + PyGILState_STATE state; + if (nogil) + state = PyGILState_Ensure(); +#endif + __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); + if (full_traceback) { + Py_XINCREF(old_exc); + Py_XINCREF(old_val); + Py_XINCREF(old_tb); + __Pyx_ErrRestore(old_exc, old_val, old_tb); + PyErr_PrintEx(1); + } + #if PY_MAJOR_VERSION < 3 + ctx = PyString_FromString(name); + #else + ctx = PyUnicode_FromString(name); + #endif + __Pyx_ErrRestore(old_exc, old_val, old_tb); + if (!ctx) { + PyErr_WriteUnraisable(Py_None); + } else { + PyErr_WriteUnraisable(ctx); + Py_DECREF(ctx); + } +#ifdef WITH_THREAD + if (nogil) + PyGILState_Release(state); +#endif +} + +static CYTHON_INLINE PyObject* __Pyx_decode_c_bytes( + const char* cstring, Py_ssize_t length, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + if (unlikely((start < 0) | (stop < 0))) { + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (stop > length) + stop = length; + length = stop - start; + if (unlikely(length <= 0)) + return PyUnicode_FromUnicode(NULL, 0); + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +static CYTHON_INLINE int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (!j) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_COMPILING_IN_CPYTHON + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) { + PyObject* old = PyList_GET_ITEM(o, n); + Py_INCREF(v); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 1; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (PyErr_ExceptionMatches(PyExc_OverflowError)) + PyErr_Clear(); + else + return -1; + } + } + return m->sq_ass_item(o, i, v); + } + } +#else +#if CYTHON_COMPILING_IN_PYPY + if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) { +#else + if (is_list || PySequence_Check(o)) { +#endif + return PySequence_SetItem(o, i, v); + } +#endif + return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_EqObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + if (op1 == op2) { + Py_RETURN_TRUE; + } + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long a = PyInt_AS_LONG(op1); + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } + #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15 + default: return PyLong_Type.tp_richcompare(op1, op2, Py_EQ); + #else + default: Py_RETURN_FALSE; + #endif + } + } + if (a == b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + if ((double)a == (double)b) { + Py_RETURN_TRUE; + } else { + Py_RETURN_FALSE; + } + } + return PyObject_RichCompare(op1, op2, Py_EQ); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseClosureNameError(const char *varname) { + PyErr_Format(PyExc_NameError, "free variable '%s' referenced before assignment in enclosing scope", varname); +} + +static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) { + PyObject* value; +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (unlikely(PyErr_Occurred())) + return NULL; + value = default_value; + } + Py_INCREF(value); +#else + if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) { + value = PyDict_GetItem(d, key); + if (unlikely(!value)) { + value = default_value; + } + Py_INCREF(value); + } else { + if (default_value == Py_None) + default_value = NULL; + value = PyObject_CallMethodObjArgs( + d, __pyx_n_s_get, key, default_value, NULL); + } +#endif + return value; +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, CYTHON_UNUSED long intval, CYTHON_UNUSED int inplace) { + #if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(op1))) { + const long b = intval; + long x; + long a = PyInt_AS_LONG(op1); + x = (long)((unsigned long)a + b); + if (likely((x^a) >= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS && PY_MAJOR_VERSION >= 3 + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; + } + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +static PyObject *__Pyx_CalculateMetaclass(PyTypeObject *metaclass, PyObject *bases) { + Py_ssize_t i, nbases = PyTuple_GET_SIZE(bases); + for (i=0; i < nbases; i++) { + PyTypeObject *tmptype; + PyObject *tmp = PyTuple_GET_ITEM(bases, i); + tmptype = Py_TYPE(tmp); +#if PY_MAJOR_VERSION < 3 + if (tmptype == &PyClass_Type) + continue; +#endif + if (!metaclass) { + metaclass = tmptype; + continue; + } + if (PyType_IsSubtype(metaclass, tmptype)) + continue; + if (PyType_IsSubtype(tmptype, metaclass)) { + metaclass = tmptype; + continue; + } + PyErr_SetString(PyExc_TypeError, + "metaclass conflict: " + "the metaclass of a derived class " + "must be a (non-strict) subclass " + "of the metaclasses of all its bases"); + return NULL; + } + if (!metaclass) { +#if PY_MAJOR_VERSION < 3 + metaclass = &PyClass_Type; +#else + metaclass = &PyType_Type; +#endif + } + Py_INCREF((PyObject*) metaclass); + return (PyObject*) metaclass; +} + +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* fake_module; + PyTypeObject* cached_type = NULL; + fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); + if (!fake_module) return NULL; + Py_INCREF(fake_module); + cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); + if (cached_type) { + if (!PyType_Check((PyObject*)cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", + type->tp_name); + goto bad; + } + if (cached_type->tp_basicsize != type->tp_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + type->tp_name); + goto bad; + } + } else { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; + } +done: + Py_DECREF(fake_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure) +{ + if (unlikely(op->func_doc == NULL)) { + if (op->func.m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(op->func.m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp = op->func_doc; + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + op->func_doc = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(op->func.m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = op->func_name; + Py_INCREF(value); + op->func_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_qualname); + return op->func_qualname; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = op->func_qualname; + Py_INCREF(value); + op->func_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure) +{ + PyObject *self; + self = m->func_closure; + if (self == NULL) + self = Py_None; + Py_INCREF(self); + return self; +} +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value) +{ + PyObject *tmp; + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + tmp = op->func_dict; + Py_INCREF(value); + op->func_dict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op) +{ + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op) +{ + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_COMPILING_IN_CPYTHON + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyTuple_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_tuple; + op->defaults_tuple = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value) { + value = Py_None; + } else if (value != Py_None && !PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + Py_INCREF(value); + tmp = op->defaults_kwdict; + op->defaults_kwdict = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) { + PyObject* tmp; + if (!value || value == Py_None) { + value = NULL; + } else if (!PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + tmp = op->func_annotations; + op->func_annotations = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { + {(char *) "__module__", T_OBJECT, offsetof(__pyx_CyFunctionObject, func.m_module), PY_WRITE_RESTRICTED, 0}, + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromString(m->func.m_ml->ml_name); +#else + return PyString_FromString(m->func.m_ml->ml_name); +#endif +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type); + if (op == NULL) + return NULL; + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + op->func.m_ml = ml; + op->func.m_self = (PyObject *) op; + Py_XINCREF(closure); + op->func_closure = closure; + Py_XINCREF(module); + op->func.m_module = module; + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + op->func_classobj = NULL; + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + PyObject_GC_Track(op); + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); + Py_CLEAR(m->func.m_module); + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + Py_CLEAR(m->func_classobj); + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyMem_Free(m->defaults); + m->defaults = NULL; + } + return 0; +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + PyObject_GC_Del(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); + Py_VISIT(m->func.m_module); + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); + Py_VISIT(m->func_classobj); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); + } + return 0; +} +static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type) +{ + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) { + Py_INCREF(func); + return func; + } + if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) { + if (type == NULL) + type = (PyObject *)(Py_TYPE(obj)); + return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type))); + } + if (obj == Py_None) + obj = NULL; + return __Pyx_PyMethod_New(func, obj, type); +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); +#else + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); +#endif +} +#if CYTHON_COMPILING_IN_PYPY +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + PyObject *self = f->m_self; + Py_ssize_t size; + switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 0)) + return (*meth)(self, NULL); + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + size = PyTuple_GET_SIZE(arg); + if (likely(size == 1)) { + PyObject *result, *arg0 = PySequence_ITEM(arg, 0); + if (unlikely(!arg0)) return NULL; + result = (*meth)(self, arg0); + Py_DECREF(arg0); + return result; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags in " + "__Pyx_CyFunction_Call. METH_OLDARGS is no " + "longer supported!"); + return NULL; + } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); + return NULL; +} +#else +static PyObject * __Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + return PyCFunction_Call(func, arg, kw); +} +#endif +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, + 0, + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, +#else + 0, +#endif + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_Call, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), +#else + offsetof(PyCFunctionObject, m_weakreflist), +#endif + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_CyFunction_descr_get, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +}; +static int __pyx_CyFunction_init(void) { +#if !CYTHON_COMPILING_IN_PYPY + __pyx_CyFunctionType_type.tp_call = PyCFunction_Call; +#endif + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); + if (__pyx_CyFunctionType == NULL) { + return -1; + } + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyMem_Malloc(size); + if (!m->defaults) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +static PyObject *__Pyx_Py3MetaclassPrepare(PyObject *metaclass, PyObject *bases, PyObject *name, + PyObject *qualname, PyObject *mkw, PyObject *modname, PyObject *doc) { + PyObject *ns; + if (metaclass) { + PyObject *prep = __Pyx_PyObject_GetAttrStr(metaclass, __pyx_n_s_prepare); + if (prep) { + PyObject *pargs = PyTuple_Pack(2, name, bases); + if (unlikely(!pargs)) { + Py_DECREF(prep); + return NULL; + } + ns = PyObject_Call(prep, pargs, mkw); + Py_DECREF(prep); + Py_DECREF(pargs); + } else { + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + PyErr_Clear(); + ns = PyDict_New(); + } + } else { + ns = PyDict_New(); + } + if (unlikely(!ns)) + return NULL; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_module, modname) < 0)) goto bad; + if (unlikely(PyObject_SetItem(ns, __pyx_n_s_qualname, qualname) < 0)) goto bad; + if (unlikely(doc && PyObject_SetItem(ns, __pyx_n_s_doc, doc) < 0)) goto bad; + return ns; +bad: + Py_DECREF(ns); + return NULL; +} +static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases, + PyObject *dict, PyObject *mkw, + int calculate_metaclass, int allow_py2_metaclass) { + PyObject *result, *margs; + PyObject *owned_metaclass = NULL; + if (allow_py2_metaclass) { + owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass); + if (owned_metaclass) { + metaclass = owned_metaclass; + } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) { + PyErr_Clear(); + } else { + return NULL; + } + } + if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) { + metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases); + Py_XDECREF(owned_metaclass); + if (unlikely(!metaclass)) + return NULL; + owned_metaclass = metaclass; + } + margs = PyTuple_Pack(3, name, bases, dict); + if (unlikely(!margs)) { + result = NULL; + } else { + result = PyObject_Call(metaclass, margs, mkw); + Py_DECREF(margs); + } + Py_XDECREF(owned_metaclass); + return result; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_MUMPS_INT(MUMPS_INT value) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(MUMPS_INT) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(MUMPS_INT), + little, !is_unsigned); + } +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; +#else + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); +#endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} + +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + PyObject *method, *result = NULL; + method = __Pyx_PyObject_GetAttrStr(obj, method_name); + if (unlikely(!method)) goto bad; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(PyMethod_Check(method))) { + PyObject *self = PyMethod_GET_SELF(method); + if (likely(self)) { + PyObject *args; + PyObject *function = PyMethod_GET_FUNCTION(method); + args = PyTuple_New(2); + if (unlikely(!args)) goto bad; + Py_INCREF(self); + PyTuple_SET_ITEM(args, 0, self); + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 1, arg); + Py_INCREF(function); + Py_DECREF(method); method = NULL; + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); + return result; + } + } +#endif + result = __Pyx_PyObject_CallOneArg(method, arg); +bad: + Py_XDECREF(method); + return result; +} + +#include +#include +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static PyObject *__Pyx_Coroutine_Close(PyObject *self); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) +#if 1 || PY_VERSION_HEX < 0x030300B0 +static int __Pyx_PyGen_FetchStopIterationValue(PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { +#if PY_VERSION_HEX >= 0x030300A0 + if (ev && Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } +#endif + if (!ev || !PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + ev = Py_None; + } else if (PyTuple_Check(ev)) { + if (PyTuple_GET_SIZE(ev) >= 1) { + PyObject *value; +#if CYTHON_COMPILING_IN_CPYTHON + value = PySequence_ITEM(ev, 0); +#else + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); +#endif + Py_DECREF(ev); + ev = value; + } else { + Py_INCREF(Py_None); + Py_DECREF(ev); + ev = Py_None; + } + } + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = ev; + return 0; + } + } else if (!PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); +#if PY_VERSION_HEX >= 0x030300A0 + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + Py_DECREF(ev); +#else + { + PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); + Py_DECREF(ev); + if (likely(args)) { + value = PySequence_GetItem(args, 0); + Py_DECREF(args); + } + if (unlikely(!value)) { + __Pyx_ErrRestore(NULL, NULL, NULL); + Py_INCREF(Py_None); + value = Py_None; + } + } +#endif + *pvalue = value; + return 0; +} +#endif +static CYTHON_INLINE +void __Pyx_Coroutine_ExceptionClear(__pyx_CoroutineObject *self) { + PyObject *exc_type = self->exc_type; + PyObject *exc_value = self->exc_value; + PyObject *exc_traceback = self->exc_traceback; + self->exc_type = NULL; + self->exc_value = NULL; + self->exc_traceback = NULL; + Py_XDECREF(exc_type); + Py_XDECREF(exc_value); + Py_XDECREF(exc_traceback); +} +static CYTHON_INLINE +int __Pyx_Coroutine_CheckRunning(__pyx_CoroutineObject *gen) { + if (unlikely(gen->is_running)) { + PyErr_SetString(PyExc_ValueError, + "generator already executing"); + return 1; + } + return 0; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value) { + PyObject *retval; + assert(!self->is_running); + if (unlikely(self->resume_label == 0)) { + if (unlikely(value && value != Py_None)) { + PyErr_SetString(PyExc_TypeError, + "can't send non-None value to a " + "just-started generator"); + return NULL; + } + } + if (unlikely(self->resume_label == -1)) { + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } + if (value) { +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyThreadState *tstate = PyThreadState_GET(); + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_XINCREF(tstate->frame); + assert(f->f_back == NULL); + f->f_back = tstate->frame; + } +#endif + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + self->is_running = 1; + retval = self->body((PyObject *) self, value); + self->is_running = 0; + if (retval) { + __Pyx_ExceptionSwap(&self->exc_type, &self->exc_value, + &self->exc_traceback); +#if CYTHON_COMPILING_IN_PYPY +#else + if (self->exc_traceback) { + PyTracebackObject *tb = (PyTracebackObject *) self->exc_traceback; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + } +#endif + } else { + __Pyx_Coroutine_ExceptionClear(self); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_MethodReturn(PyObject *retval) { + if (unlikely(!retval && !PyErr_Occurred())) { + PyErr_SetNone(PyExc_StopIteration); + } + return retval; +} +static CYTHON_INLINE +PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { + PyObject *ret; + PyObject *val = NULL; + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen_FetchStopIterationValue(&val); + ret = __Pyx_Coroutine_SendEx(gen, val); + Py_XDECREF(val); + return ret; +} +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + { + if (value == Py_None) + ret = PyIter_Next(yf); + else + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); + } + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + retval = __Pyx_Coroutine_FinishDelegation(gen); + } else { + retval = __Pyx_Coroutine_SendEx(gen, value); + } + return __Pyx_Coroutine_MethodReturn(retval); +} +static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + PyObject *retval = NULL; + int err = 0; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + retval = __Pyx_Coroutine_Close(yf); + if (!retval) + return -1; + } else + #endif + { + PyObject *meth; + gen->is_running = 1; + meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); + if (unlikely(!meth)) { + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_WriteUnraisable(yf); + } + PyErr_Clear(); + } else { + retval = PyObject_CallFunction(meth, NULL); + Py_DECREF(meth); + if (!retval) + err = -1; + } + gen->is_running = 0; + } + Py_XDECREF(retval); + return err; +} +static PyObject *__Pyx_Generator_Next(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *yf = gen->yieldfrom; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + gen->is_running = 1; + ret = Py_TYPE(yf)->tp_iternext(yf); + gen->is_running = 0; + if (likely(ret)) { + return ret; + } + return __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_SendEx(gen, Py_None); +} +static PyObject *__Pyx_Coroutine_Close(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *retval, *raised_exception; + PyObject *yf = gen->yieldfrom; + int err = 0; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + retval = __Pyx_Coroutine_SendEx(gen, NULL); + if (retval) { + Py_DECREF(retval); + PyErr_SetString(PyExc_RuntimeError, + "generator ignored GeneratorExit"); + return NULL; + } + raised_exception = PyErr_Occurred(); + if (!raised_exception + || raised_exception == PyExc_StopIteration + || raised_exception == PyExc_GeneratorExit + || PyErr_GivenExceptionMatches(raised_exception, PyExc_GeneratorExit) + || PyErr_GivenExceptionMatches(raised_exception, PyExc_StopIteration)) + { + if (raised_exception) PyErr_Clear(); + Py_INCREF(Py_None); + return Py_None; + } + return NULL; +} +static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *typ; + PyObject *tb = NULL; + PyObject *val = NULL; + PyObject *yf = gen->yieldfrom; + if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) + return NULL; + if (unlikely(__Pyx_Coroutine_CheckRunning(gen))) + return NULL; + if (yf) { + PyObject *ret; + Py_INCREF(yf); + if (PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit)) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); + goto throw_here; + } + gen->is_running = 1; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Throw(yf, args); + } else + #endif + { + PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { + gen->is_running = 0; + return NULL; + } + PyErr_Clear(); + __Pyx_Coroutine_Undelegate(gen); + gen->is_running = 0; + goto throw_here; + } + ret = PyObject_CallObject(meth, args); + Py_DECREF(meth); + } + gen->is_running = 0; + Py_DECREF(yf); + if (!ret) { + ret = __Pyx_Coroutine_FinishDelegation(gen); + } + return __Pyx_Coroutine_MethodReturn(ret); + } +throw_here: + __Pyx_Raise(typ, val, tb, NULL); + return __Pyx_Coroutine_MethodReturn(__Pyx_Coroutine_SendEx(gen, NULL)); +} +static int __Pyx_Coroutine_traverse(PyObject *self, visitproc visit, void *arg) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + Py_VISIT(gen->exc_type); + Py_VISIT(gen->exc_value); + Py_VISIT(gen->exc_traceback); + return 0; +} +static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + Py_CLEAR(gen->yieldfrom); + Py_CLEAR(gen->exc_type); + Py_CLEAR(gen->exc_value); + Py_CLEAR(gen->exc_traceback); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + return 0; +} +static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + if (gen->gi_weakreflist != NULL) + PyObject_ClearWeakRefs(self); + if (gen->resume_label > 0) { + PyObject_GC_Track(self); +#if PY_VERSION_HEX >= 0x030400a1 + if (PyObject_CallFinalizerFromDealloc(self)) +#else + Py_TYPE(gen)->tp_del(self); + if (self->ob_refcnt > 0) +#endif + { + return; + } + PyObject_GC_UnTrack(self); + } + __Pyx_Coroutine_clear(self); + PyObject_GC_Del(gen); +} +static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *res; + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + if (gen->resume_label <= 0) + return ; +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt == 0); + self->ob_refcnt = 1; +#endif + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + res = __Pyx_Coroutine_Close(self); + if (res == NULL) + PyErr_WriteUnraisable(self); + else + Py_DECREF(res); + __Pyx_ErrRestore(error_type, error_value, error_traceback); +#if PY_VERSION_HEX < 0x030400a1 + assert(self->ob_refcnt > 0); + if (--self->ob_refcnt == 0) { + return; + } + { + Py_ssize_t refcnt = self->ob_refcnt; + _Py_NewReference(self); + self->ob_refcnt = refcnt; + } +#if CYTHON_COMPILING_IN_CPYTHON + assert(PyType_IS_GC(self->ob_type) && + _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); + _Py_DEC_REFTOTAL; +#endif +#ifdef COUNT_ALLOCS + --Py_TYPE(self)->tp_frees; + --Py_TYPE(self)->tp_allocs; +#endif +#endif +} +static PyObject * +__Pyx_Coroutine_get_name(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_name); + return self->gi_name; +} +static int +__Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + tmp = self->gi_name; + Py_INCREF(value); + self->gi_name = value; + Py_XDECREF(tmp); + return 0; +} +static PyObject * +__Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self) +{ + Py_INCREF(self->gi_qualname); + return self->gi_qualname; +} +static int +__Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value) +{ + PyObject *tmp; +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) { +#else + if (unlikely(value == NULL || !PyString_Check(value))) { +#endif + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + tmp = self->gi_qualname; + Py_INCREF(value); + self->gi_qualname = value; + Py_XDECREF(tmp); + return 0; +} +static __pyx_CoroutineObject *__Pyx__Coroutine_New(PyTypeObject* type, __pyx_coroutine_body_t body, + PyObject *closure, PyObject *name, PyObject *qualname) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (gen == NULL) + return NULL; + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->exc_type = NULL; + gen->exc_value = NULL; + gen->exc_traceback = NULL; + gen->gi_weakreflist = NULL; + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + PyObject_GC_Track(gen); + return gen; +} + +static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + int result; + PyObject *globals, *result_obj; + globals = PyDict_New(); if (unlikely(!globals)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_coroutine_type", + #ifdef __Pyx_Coroutine_USED + (PyObject*)__pyx_CoroutineType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + result = PyDict_SetItemString(globals, "_cython_generator_type", + #ifdef __Pyx_Generator_USED + (PyObject*)__pyx_GeneratorType); + #else + Py_None); + #endif + if (unlikely(result < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; + if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; + result_obj = PyRun_String(py_code, Py_file_input, globals, globals); + if (unlikely(!result_obj)) goto ignore; + Py_DECREF(result_obj); + Py_DECREF(globals); + return module; +ignore: + Py_XDECREF(globals); + PyErr_WriteUnraisable(module); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { + Py_DECREF(module); + module = NULL; + } +#else + py_code++; +#endif + return module; +} + +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) +static PyObject* __Pyx_patch_abc_module(PyObject *module); +static PyObject* __Pyx_patch_abc_module(PyObject *module) { + module = __Pyx_Coroutine_patch_module( + module, "" +"if _cython_generator_type is not None:\n" +" try: Generator = _module.Generator\n" +" except AttributeError: pass\n" +" else: Generator.register(_cython_generator_type)\n" +"if _cython_coroutine_type is not None:\n" +" try: Coroutine = _module.Coroutine\n" +" except AttributeError: pass\n" +" else: Coroutine.register(_cython_coroutine_type)\n" + ); + return module; +} +#endif +static int __Pyx_patch_abc(void) { +#if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + static int abc_patched = 0; + if (!abc_patched) { + PyObject *module; + module = PyImport_ImportModule((PY_VERSION_HEX >= 0x03030000) ? "collections.abc" : "collections"); + if (!module) { + PyErr_WriteUnraisable(NULL); + if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, + ((PY_VERSION_HEX >= 0x03030000) ? + "Cython module failed to register with collections.abc module" : + "Cython module failed to register with collections module"), 1) < 0)) { + return -1; + } + } else { + module = __Pyx_patch_abc_module(module); + abc_patched = 1; + if (unlikely(!module)) + return -1; + Py_DECREF(module); + } + module = PyImport_ImportModule("backports_abc"); + if (module) { + module = __Pyx_patch_abc_module(module); + Py_XDECREF(module); + } + if (!module) { + PyErr_Clear(); + } + } +#else + if (0) __Pyx_Coroutine_patch_module(NULL, NULL); +#endif + return 0; +} + +static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + (char*) PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close, METH_NOARGS, + (char*) PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {0, 0, 0, 0} +}; +static PyMemberDef __pyx_Generator_memberlist[] = { + {(char *) "gi_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, + {(char*) "gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + (char*) PyDoc_STR("object being iterated by 'yield from', or None")}, + {0, 0, 0, 0, 0} +}; +static PyGetSetDef __pyx_Generator_getsets[] = { + {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + (char*) PyDoc_STR("name of the generator"), 0}, + {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + (char*) PyDoc_STR("qualified name of the generator"), 0}, + {0, 0, 0, 0, 0} +}; +static PyTypeObject __pyx_GeneratorType_type = { + PyVarObject_HEAD_INIT(0, 0) + "generator", + sizeof(__pyx_CoroutineObject), + 0, + (destructor) __Pyx_Coroutine_dealloc, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, + 0, + (traverseproc) __Pyx_Coroutine_traverse, + 0, + 0, + offsetof(__pyx_CoroutineObject, gi_weakreflist), + 0, + (iternextfunc) __Pyx_Generator_Next, + __pyx_Generator_methods, + __pyx_Generator_memberlist, + __pyx_Generator_getsets, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#else + __Pyx_Coroutine_del, +#endif + 0, +#if PY_VERSION_HEX >= 0x030400a1 + __Pyx_Coroutine_del, +#endif +}; +static int __pyx_Generator_init(void) { + __pyx_GeneratorType_type.tp_getattro = PyObject_GenericGetAttr; + __pyx_GeneratorType_type.tp_iter = PyObject_SelfIter; + __pyx_GeneratorType = __Pyx_FetchCommonType(&__pyx_GeneratorType_type); + if (unlikely(!__pyx_GeneratorType)) { + return -1; + } + return 0; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +static int __Pyx_ExportFunction(const char *name, void (*f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(__pyx_m, (char *)"__pyx_capi__"); + if (!d) { + PyErr_Clear(); + d = PyDict_New(); + if (!d) + goto bad; + Py_INCREF(d); + if (PyModule_AddObject(__pyx_m, (char *)"__pyx_capi__", d) < 0) + goto bad; + } + tmp.fp = f; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(tmp.p, sig, 0); +#else + cobj = PyCObject_FromVoidPtrAndDesc(tmp.p, (void *)sig, 0); +#endif + if (!cobj) + goto bad; + if (PyDict_SetItemString(d, name, cobj) < 0) + goto bad; + Py_DECREF(cobj); + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(cobj); + Py_XDECREF(d); + return -1; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/mumps_INT32_FLOAT64.pxd b/mumps/src/mumps_INT32_FLOAT64.pxd new file mode 100644 index 0000000..f282b5e --- /dev/null +++ b/mumps/src/mumps_INT32_FLOAT64.pxd @@ -0,0 +1,186 @@ +cimport numpy as cnp + +cdef extern from "mumps_c_types.h": + + ctypedef int MUMPS_INT + ctypedef cnp.int8_t MUMPS_INT8 + + ctypedef float SMUMPS_COMPLEX + ctypedef float SMUMPS_REAL + + ctypedef double DMUMPS_COMPLEX + ctypedef double DMUMPS_REAL + + ctypedef struct mumps_complex: + float r,i + + ctypedef mumps_complex CMUMPS_COMPLEX + ctypedef float CMUMPS_REAL + + ctypedef struct mumps_double_complex: + double r, i + + ctypedef mumps_double_complex ZMUMPS_COMPLEX + ctypedef double ZMUMPS_REAL + +cdef extern from "dmumps_c.h": + ctypedef struct DMUMPS_STRUC_C: + MUMPS_INT sym, par, job + MUMPS_INT comm_fortran # Fortran communicator + MUMPS_INT icntl[40] + MUMPS_INT keep[500] + DMUMPS_REAL cntl[15] + DMUMPS_REAL dkeep[130]; + MUMPS_INT8 keep8[150]; + MUMPS_INT n + + # used in matlab interface to decide if we + # free + malloc when we have large variation + MUMPS_INT nz_alloc + + # Assembled entry + MUMPS_INT nz + MUMPS_INT *irn + MUMPS_INT *jcn + DMUMPS_COMPLEX *a + + # Distributed entry + MUMPS_INT nz_loc + MUMPS_INT *irn_loc + MUMPS_INT *jcn_loc + DMUMPS_COMPLEX *a_loc + + # Element entry + MUMPS_INT nelt + MUMPS_INT *eltptr + MUMPS_INT *eltvar + DMUMPS_COMPLEX *a_elt + + # Ordering, if given by user + MUMPS_INT *perm_in + + # Orderings returned to user + MUMPS_INT *sym_perm # symmetric permutation + MUMPS_INT *uns_perm # column permutation + + # Scaling (input only in this version) + DMUMPS_REAL *colsca + DMUMPS_REAL *rowsca + MUMPS_INT colsca_from_mumps; + MUMPS_INT rowsca_from_mumps; + + + # RHS, solution, ouptput data and statistics + DMUMPS_COMPLEX *rhs + DMUMPS_COMPLEX *redrhs + DMUMPS_COMPLEX *rhs_sparse + DMUMPS_COMPLEX *sol_loc + MUMPS_INT *irhs_sparse + MUMPS_INT *irhs_ptr + MUMPS_INT *isol_loc + MUMPS_INT nrhs, lrhs, lredrhs, nz_rhs, lsol_loc + MUMPS_INT schur_mloc, schur_nloc, schur_lld + MUMPS_INT mblock, nblock, nprow, npcol + MUMPS_INT info[40] + MUMPS_INT infog[40] + DMUMPS_REAL rinfo[40] + DMUMPS_REAL rinfog[40] + + # Null space + MUMPS_INT deficiency + MUMPS_INT *pivnul_list + MUMPS_INT *mapping + + # Schur + MUMPS_INT size_schur + MUMPS_INT *listvar_schur + DMUMPS_COMPLEX *schur + + # Internal parameters + MUMPS_INT instance_number + DMUMPS_COMPLEX *wk_user + + char *version_number + # For out-of-core + char *ooc_tmpdir + char *ooc_prefix + # To save the matrix in matrix market format + char *write_problem + MUMPS_INT lwk_user + + cdef void dmumps_c(DMUMPS_STRUC_C *) + +cdef class mumps_int_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + int version. + + """ + cdef: + MUMPS_INT * array + int ub + + cdef get_array(self, MUMPS_INT * array, int ub = ?) + +cdef class dmumps_real_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + Real version. + + """ + cdef: + DMUMPS_REAL * array + int ub + + cdef get_array(self, DMUMPS_REAL * array, int ub = ?) + +cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + +cdef class BaseMUMPSSolver_INT32_FLOAT64: + cdef: + + MUMPS_INT nrow + MUMPS_INT ncol + MUMPS_INT nnz + + # MUMPS + DMUMPS_STRUC_C params + + # internal classes for getters and setters + mumps_int_array icntl + mumps_int_array info + mumps_int_array infog + + dmumps_real_array cntl + dmumps_real_array rinfo + dmumps_real_array rinfog + + MUMPS_INT * a_row + MUMPS_INT * a_col + DMUMPS_COMPLEX * a_val + + bint analyzed + bint factorized + bint out_of_core + + object analysis_stats + object factorize_stats + object solve_stats + + cdef get_data_pointers(self, + MUMPS_INT * a_row, + MUMPS_INT * a_col, + DMUMPS_COMPLEX * a_val) + + cdef initialize_mumps_struct(self, comm_fortran, sym) + + cdef mumps_call(self) + + cdef set_centralized_assembled_matrix(self) + + cdef solve_dense(self, DMUMPS_COMPLEX * rhs, + MUMPS_INT rhs_length, MUMPS_INT nrhs) + cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + DMUMPS_COMPLEX * rhs_val, + MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + DMUMPS_COMPLEX * x, MUMPS_INT x_length) diff --git a/mumps/src/mumps_INT32_FLOAT64.pyx b/mumps/src/mumps_INT32_FLOAT64.pyx new file mode 100644 index 0000000..08ec1ca --- /dev/null +++ b/mumps/src/mumps_INT32_FLOAT64.pyx @@ -0,0 +1,947 @@ +""" +This is the base class for the interface to MUMPS (http://mumps.enseeiht.fr/index.php?page=home) + +""" + +""" +Some notes for the maintainers of this library. + +Basic working: +-------------- + +MUMPS working is simple: + +- initialize/modify the C struct MUMPS_STRUC_C; +- call mumps_c(MUMPS_STRUC_C *). + +For example: + +# analyze +MUMPS_STRUC_C.job = 1 +mumps_c(&MUMPS_STRUC_C) + +# factorize +MUMPS_STRUC_C.job = 2 +mumps_c(&MUMPS_STRUC_C) + +# solve +MUMPS_STRUC_C.job = 3 +mumps_c(&MUMPS_STRUC_C) + +etc. + +Access to: + - icntl + - info + - infog + - cntl + - rinfo + - rinfog + +**must** be done through properties!!!! + + +Typed C struct: +--------------- + +Each MUMPS_STRUC_C is specialized and prefixed by a letter: + +- SMUMPS_STRUC_C: simple precision; +- DMUMPS_STRUC_C: double precision; +- CMUMPS_STRUC_C: simple complex; +- ZMUMPS_STRUC_C: double complex. + +In MUMPSContext_INT32_FLOAT64, (S,D,C,Z)mumps_c() is called by self.mumps_call(). + + can be used for **ALL** four types. + +Solve: +------ + +MUMPS **overwrites** the rhs member and replaces it by the solution(s) it finds. +If sparse solve is used, the solution is placed in a dummy dense rhs member. + +The rhs member can be a matrix or a vector. + +1-based index arrays: +--------------------- + +MUMPS uses exclusively FORTRAN routines and by consequence **all** array indices start with index **1** (not 0). + +Default 32 bit integers compilation: +------------------------------------ + +By default, MUMPS is compiled in 32 bit integers **unless** it is compiled with the option -DINTSIZE64. +32 and 64 bit versions are **not** compatible. + +Lib creation: +------------- + +The :file:`libmpiseq.so` file is *missing* by default in lib and must be added by hand. It is compiled in directory +libseq. :file:`libmpiseq.so` is essentially a dummy file to deal with sequential code. + +The order in which the library (.so) files are given to construct the MUMPS part +of this interface **is** important... and not standard. + +""" + +from mumps.mumps_statistics import AnalysisStatistics, FactorizationStatistics, SolveStatistics + +from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free +from cpython cimport Py_INCREF, Py_DECREF + +from libc.stdint cimport int64_t +from libc.string cimport strncpy + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + +import time + +cdef extern from "mumps_c_types.h": + + ctypedef int MUMPS_INT + ctypedef int64_t MUMPS_INT8 # warning: mumps uses "stdint.h" which might define int64_t as long long... + + ctypedef float SMUMPS_COMPLEX + ctypedef float SMUMPS_REAL + + ctypedef double DMUMPS_COMPLEX + ctypedef double DMUMPS_REAL + + ctypedef struct mumps_complex: + float r,i + + ctypedef mumps_complex CMUMPS_COMPLEX + ctypedef float CMUMPS_REAL + + ctypedef struct mumps_double_complex: + double r, i + + ctypedef mumps_double_complex ZMUMPS_COMPLEX + ctypedef double ZMUMPS_REAL + +cdef extern from "dmumps_c.h": + ctypedef struct DMUMPS_STRUC_C: + MUMPS_INT sym, par, job + MUMPS_INT comm_fortran # Fortran communicator + MUMPS_INT icntl[40] + MUMPS_INT keep[500] + DMUMPS_REAL cntl[15] + DMUMPS_REAL dkeep[130]; + MUMPS_INT8 keep8[150]; + MUMPS_INT n + + # used in matlab interface to decide if we + # free + malloc when we have large variation + MUMPS_INT nz_alloc + + # Assembled entry + MUMPS_INT nz + MUMPS_INT *irn + MUMPS_INT *jcn + DMUMPS_COMPLEX *a + + # Distributed entry + MUMPS_INT nz_loc + MUMPS_INT *irn_loc + MUMPS_INT *jcn_loc + DMUMPS_COMPLEX *a_loc + + # Element entry + MUMPS_INT nelt + MUMPS_INT *eltptr + MUMPS_INT *eltvar + DMUMPS_COMPLEX *a_elt + + # Ordering, if given by user + MUMPS_INT *perm_in + + # Orderings returned to user + MUMPS_INT *sym_perm # symmetric permutation + MUMPS_INT *uns_perm # column permutation + + # Scaling (input only in this version) + DMUMPS_REAL *colsca + DMUMPS_REAL *rowsca + MUMPS_INT colsca_from_mumps; + MUMPS_INT rowsca_from_mumps; + + + # RHS, solution, ouptput data and statistics + DMUMPS_COMPLEX *rhs + DMUMPS_COMPLEX *redrhs + DMUMPS_COMPLEX *rhs_sparse + DMUMPS_COMPLEX *sol_loc + MUMPS_INT *irhs_sparse + MUMPS_INT *irhs_ptr + MUMPS_INT *isol_loc + MUMPS_INT nrhs, lrhs, lredrhs, nz_rhs, lsol_loc + MUMPS_INT schur_mloc, schur_nloc, schur_lld + MUMPS_INT mblock, nblock, nprow, npcol + MUMPS_INT info[40] + MUMPS_INT infog[40] + DMUMPS_REAL rinfo[40] + DMUMPS_REAL rinfog[40] + + # Null space + MUMPS_INT deficiency + MUMPS_INT *pivnul_list + MUMPS_INT *mapping + + # Schur + MUMPS_INT size_schur + MUMPS_INT *listvar_schur + DMUMPS_COMPLEX *schur + + # Internal parameters + MUMPS_INT instance_number + DMUMPS_COMPLEX *wk_user + + char *version_number + # For out-of-core + char *ooc_tmpdir + char *ooc_prefix + # To save the matrix in matrix market format + char *write_problem + MUMPS_INT lwk_user + + cdef void dmumps_c(DMUMPS_STRUC_C *) + +# MUMPS possible ordering methods +orderings = { 'amd' : 0, 'amf' : 2, 'scotch' : 3, 'pord' : 4, 'metis' : 5, + 'qamd' : 6, 'auto' : 7 } + +ordering_name = [ 'amd', 'user-defined', 'amf', + 'scotch', 'pord', 'metis', 'qamd'] + +# MUMPS ERRORS +# TODO: decouple +error_messages = { + -5 : "Not enough memory during analysis phase", + -6 : "Matrix is singular in structure", + -7 : "Not enough memory during analysis phase", + -10 : "Matrix is numerically singular", + -11 : "The authors of MUMPS would like to hear about this", + -12 : "The authors of MUMPS would like to hear about this", + -13 : "Not enough memory" +} + + +class MUMPSError(RuntimeError): + def __init__(self, infog): + self.error = infog[1] + if self.error in error_messages: + msg = "{}. (MUMPS error {})".format( + error_messages[self.error], self.error) + else: + msg = "MUMPS failed with error {}.".format(self.error) + + RuntimeError.__init__(self, msg) + +# MUMPS HELPERS +cdef class mumps_int_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + + Integer version. + + """ + def __cinit__(self): + pass + + cdef get_array(self, MUMPS_INT * array, int ub = 40): + """ + Args: + ub: upper bound. + """ + self.ub = ub + self.array = array + + def __getitem__(self, key): + if key < 1: + raise IndexError('MUMPS index must be >= 1 (Fortran style)') + if key > self.ub: + raise IndexError('MUMPS index must be <= %d' % self.ub) + + return self.array[key - 1] + + def __setitem__(self, key, value): + self.array[key - 1] = value + +cdef class dmumps_real_array: + """ + Internal classes to use x[i] = value and x[i] setters and getters + + Real version. + + """ + def __cinit__(self): + pass + + cdef get_array(self, DMUMPS_REAL * array, int ub = 40): + """ + Args: + ub: upper bound. + """ + self.ub = ub + self.array = array + + def __getitem__(self, key): + if key < 1: + raise IndexError('MUMPS index must be >= 1 (Fortran style)') + if key > self.ub: + raise IndexError('MUMPS index must be <= %d' % self.ub) + + return self.array[key - 1] + + def __setitem__(self, key, value): + self.array[key - 1] = value + + + +cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size): + cdef: + MUMPS_INT i + + for i from 0 <= i < a_size: + a[i] += 1 + +# MUMPS CONTEXT +cdef class BaseMUMPSSolver_INT32_FLOAT64: + """ + Base MUMPS Context. + + This version **only** deals with array pointers. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + """ + + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + """ + self.nrow = n + self.ncol = n + self.nnz = nnz + + assert self.ncol == self.nrow + + self.initialize_mumps_struct(comm_fortran, sym) + + # `initialize_mumps_struct` **must** be called before assigning + # a value to n (size of the matrix) + self.params.n = self.nrow + + self.analyzed = False + self.factorized = False + self.out_of_core = False + + if not verbose: + self.set_silent() + + + cdef initialize_mumps_struct(self, comm_fortran, sym): + """ + Initialize MUMPS structure and make control parameters and information + avalaible to user. + + Args: + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + """ + self.params.job = -1 + self.params.sym = sym + self.params.par = 1 + + self.params.comm_fortran = comm_fortran + + self.mumps_call() + + # integer control parameters + self.icntl = mumps_int_array() + self.icntl.get_array(self.params.icntl) + + # integer information parameters + self.info = mumps_int_array() + self.info.get_array(self.params.info) + + # integer information parameters + self.infog = mumps_int_array() + self.infog.get_array(self.params.infog) + + # real/complex control parameters + self.cntl = dmumps_real_array() + self.cntl.get_array(self.params.cntl) + + # real/complex information parameters + self.rinfo = dmumps_real_array() + self.rinfo.get_array(self.params.rinfo) + + # real/complex information parameters + self.rinfog = dmumps_real_array() + self.rinfog.get_array(self.params.rinfog) + + + cdef get_data_pointers(self, + MUMPS_INT * a_row, + MUMPS_INT * a_col, + DMUMPS_COMPLEX * a_val): + """ + Get elements of A and their positions and transfer them to MUMPS internal structure. + + Args: + a_row: pointer to an MUMPS_INT array containing row indices of non zero elements of A. + a_col: pointer to an MUMPS_INT array containing column indices of non zero elements of A. + a_val: pointer to an MUMPS_INT array containing values of non zeros elements of A. + + Note: row and column indices are adjusted for Fortran indexing. + """ + + self.a_row = a_row + self.a_col = a_col + self.a_val = a_val + + # transform c index arrays to fortran arrays + c_to_fortran_index_array(self.a_row, self.nnz) + c_to_fortran_index_array(self.a_col, self.nnz) + + self.set_centralized_assembled_matrix() + + + cdef set_centralized_assembled_matrix(self): + """ + Set the centralized assembled matrix + The rank 0 process supplies the entire matrix. + """ + + self.params.nz = self.nnz + + self.params.irn = self.a_row + self.params.jcn = self.a_col + self.params.a = self.a_val + + + def __dealloc__(self): + # autodestruct mumps internal + self.params.job = -2 + self.mumps_call() + self.params.job = -1 + self.mumps_call() + + # Properties + # COMMON Properties + property analyzed: + def __get__(self): return self.analyzed + property factorized: + def __get__(self): return self.factorized + property sym: + def __get__(self): return self.params.sym + def __set__(self, value): self.params.sym = value + property par: + def __get__(self): return self.params.par + def __set__(self, value): self.params.par = value + property job: + def __get__(self): return self.params.job + def __set__(self, value): self.params.job = value + + property comm_fortran: + def __get__(self): return self.params.comm_fortran + def __set__(self, value): self.params.comm_fortran = value + + property icntl: + def __get__(self): + return self.icntl + + property n: + def __get__(self): return self.params.n + def __set__(self, value): self.params.n = value + property nz_alloc: + def __get__(self): return self.params.nz_alloc + def __set__(self, value): self.params.nz_alloc = value + + property nz: + def __get__(self): return self.params.nz + def __set__(self, value): self.params.nz = value + property irn: + def __get__(self): return self.params.irn + def __set__(self, long value): self.params.irn = value + property jcn: + def __get__(self): return self.params.jcn + def __set__(self, long value): self.params.jcn = value + + property nz_loc: + def __get__(self): return self.params.nz_loc + def __set__(self, value): self.params.nz_loc = value + property irn_loc: + def __get__(self): return self.params.irn_loc + def __set__(self, long value): self.params.irn_loc = value + property jcn_loc: + def __get__(self): return self.params.jcn_loc + def __set__(self, long value): self.params.jcn_loc = value + + property nelt: + def __get__(self): return self.params.nelt + def __set__(self, value): self.params.nelt = value + property eltptr: + def __get__(self): return self.params.eltptr + def __set__(self, long value): self.params.eltptr = value + property eltvar: + def __get__(self): return self.params.eltvar + def __set__(self, long value): self.params.eltvar = value + + property perm_in: + def __get__(self): return self.params.perm_in + def __set__(self, long value): self.params.perm_in = value + + property sym_perm: + def __get__(self): return self.params.sym_perm + def __set__(self, long value): self.params.sym_perm = value + property uns_perm: + def __get__(self): return self.params.uns_perm + def __set__(self, long value): self.params.uns_perm = value + + property irhs_sparse: + def __get__(self): return self.params.irhs_sparse + def __set__(self, long value): self.params.irhs_sparse = value + property irhs_ptr: + def __get__(self): return self.params.irhs_ptr + def __set__(self, long value): self.params.irhs_ptr = value + property isol_loc: + def __get__(self): return self.params.isol_loc + def __set__(self, long value): self.params.isol_loc = value + + property nrhs: + def __get__(self): return self.params.nrhs + def __set__(self, value): self.params.nrhs = value + property lrhs: + def __get__(self): return self.params.lrhs + def __set__(self, value): self.params.lrhs = value + property lredrhs: + def __get__(self): return self.params.lredrhs + def __set__(self, value): self.params.lredrhs = value + property nz_rhs: + def __get__(self): return self.params.nz_rhs + def __set__(self, value): self.params.nz_rhs = value + property lsol_loc: + def __get__(self): return self.params.lsol_loc + def __set__(self, value): self.params.lsol_loc = value + + property schur_mloc: + def __get__(self): return self.params.schur_mloc + def __set__(self, value): self.params.schur_mloc = value + property schur_nloc: + def __get__(self): return self.params.schur_nloc + def __set__(self, value): self.params.schur_nloc = value + property schur_lld: + def __get__(self): return self.params.schur_lld + def __set__(self, value): self.params.schur_lld = value + + property mblock: + def __get__(self): return self.params.mblock + def __set__(self, value): self.params.mblock = value + property nblock: + def __get__(self): return self.params.nblock + def __set__(self, value): self.params.nblock = value + property nprow: + def __get__(self): return self.params.nprow + def __set__(self, value): self.params.nprow = value + property npcol: + def __get__(self): return self.params.npcol + def __set__(self, value): self.params.npcol = value + + property info: + def __get__(self): + return self.info + + property infog: + def __get__(self): + return self.infog + + property deficiency: + def __get__(self): return self.params.deficiency + def __set__(self, value): self.params.deficiency = value + property pivnul_list: + def __get__(self): return self.params.pivnul_list + def __set__(self, long value): self.params.pivnul_list = value + property mapping: + def __get__(self): return self.params.mapping + def __set__(self, long value): self.params.mapping = value + + property size_schur: + def __get__(self): return self.params.size_schur + def __set__(self, value): self.params.size_schur = value + property listvar_schur: + def __get__(self): return self.params.listvar_schur + def __set__(self, long value): self.params.listvar_schur = value + + property instance_number: + def __get__(self): return self.params.instance_number + def __set__(self, value): self.params.instance_number = value + + property version_number: + def __get__(self): + return ( self.params.version_number).decode('ascii') + + property ooc_tmpdir: + def __get__(self): + return ( self.params.ooc_tmpdir).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.ooc_tmpdir, value, sizeof(self.params.ooc_tmpdir)) + property ooc_prefix: + def __get__(self): + return ( self.params.ooc_prefix).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.ooc_prefix, value, sizeof(self.params.ooc_prefix)) + + property write_problem: + def __get__(self): + return ( self.params.write_problem).decode('ascii') + def __set__(self, char *value): + strncpy(self.params.write_problem, value, sizeof(self.params.write_problem)) + + property lwk_user: + def __get__(self): return self.params.lwk_user + def __set__(self, value): self.params.lwk_user = value + + # TYPED Properties + property cntl: + def __get__(self): + return self.cntl + + property a: + def __get__(self): return self.params.a + def __set__(self, long value): self.params.a = value + + property a_loc: + def __get__(self): return self.params.a_loc + def __set__(self, long value): self.params.a_loc = value + + property a_elt: + def __get__(self): return self.params.a_elt + def __set__(self, long value): self.params.a_elt = value + + property colsca: + def __get__(self): return self.params.colsca + def __set__(self, long value): self.params.colsca = value + property rowsca: + def __get__(self): return self.params.rowsca + def __set__(self, long value): self.params.rowsca = value + + property rhs: + def __get__(self): return self.params.rhs + def __set__(self, long value): self.params.rhs = value + property redrhs: + def __get__(self): return self.params.redrhs + def __set__(self, long value): self.params.redrhs = value + property rhs_sparse: + def __get__(self): return self.params.rhs_sparse + def __set__(self, long value): self.params.rhs_sparse = value + property sol_loc: + def __get__(self): return self.params.sol_loc + def __set__(self, long value): self.params.sol_loc = value + + property rinfo: + def __get__(self): + return self.rinfo + + property rinfog: + def __get__(self): + return self.rinfog + + property schur: + def __get__(self): return self.params.schur + def __set__(self, long value): self.params.schur = value + + property wk_user: + def __get__(self): return self.params.wk_user + def __set__(self, long value): self.params.wk_user = value + + # MUMPS CALL + cdef mumps_call(self): + """ + Call to Xmumps_c(XMUMPS_STRUC_C). + """ + dmumps_c(&self.params) + + + def set_silent(self): + """ + Silence **all* MUMPS output. + + See MUMPS documentation. + """ + self.icntl[1] = 0 + self.icntl[2] = 0 + self.icntl[3] = 0 + self.icntl[4] = 0 + + + def analyze(self, ordering='auto'): + """ + Performs analysis step of MUMPS. + + In the analyis step, MUMPS is able to figure out a reordering for the + given matrix. It does so if `ordering` is set to 'auto'. + If not MUMPS will use the provided ordering. + MUMPS statistics for the analysis are available in `analysis_stats`. + + Args: + ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' } + ordering to use in the factorization. The availability of a + particular ordering depends on the MUMPS installation. Default is + 'auto'. + """ + if self.analyzed: + return + + self.icntl[7] = orderings[ordering] + t1 = time.clock() + self.params.job = 1 # analyse + self.mumps_call() + t2 = time.clock() + + if self.infog[1] < 0: + raise MUMPSError(self.infog) + + self.analyzed = True + + # self.analysis_stats = AnalysisStatistics(self.params, + # t2 - t1) + + def factorize(self, ordering='auto', pivot_tol=0.01): + """ + Perform the LU factorization of the matrix (or LDL' if the matrix + is symmetric). + + This factorization can then later be used to solve a linear system + with `solve`. Statistical data of the factorization is stored in + `factor_stats`. + + Args: + ordering : { 'auto', 'amd', 'amf', 'scotch', 'pord', 'metis', 'qamd' } + ordering to use in the factorization. The availability of a + particular ordering depends on the MUMPS installation. Default is + 'auto'. + pivot_tol: number in the range [0, 1] + pivoting threshold. Pivoting is typically limited in sparse + solvers, as too much pivoting destroys sparsity. 1.0 means full + pivoting, whereas 0.0 means no pivoting. Default is 0.01. + """ + # TODO: ordering + + # Analysis phase must be done before factorization + if not self.analyzed : + self.analyze(ordering=ordering) + + self.icntl[22] = 1 if self.out_of_core else 1 + self.cntl[1] = pivot_tol + self.params.job = 2 + + done = False + while not done: + t1 = time.clock() + self.mumps_call() + t2 = time.clock() + + # error -8, -9 (not enough allocated memory) is treated + # specially, by increasing the memory relaxation parameter + if self.infog[1] < 0: + if self.infog[1] in (-8, -9): + # double the additional memory + self.icntl[14] = self.icntl[14]*2 + else: + raise MUMPSError(self.infog) + else: + done = True + + self.factorized = True + # self.factorize_stats = FactorizationStatistics(self.params, t2 - t1) + + cdef solve_dense(self, DMUMPS_COMPLEX * rhs, MUMPS_INT rhs_length, MUMPS_INT nrhs): + """ + Solve a linear system after the LU (or LDL^T) factorization has previously been performed by `factorize` + + Args: + rhs: the right hand side (dense matrix or vector) + rhs_length: Length of each column of the ``rhs``. + nrhs: Number of columns in the matrix ``rhs``. + + Warning: + MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + """ + self.params.nrhs = nrhs + self.params.lrhs = rhs_length + self.params.rhs = rhs + self.params.job = 3 # solve + self.mumps_call() + + cdef solve_sparse(self, MUMPS_INT * rhs_col_ptr, MUMPS_INT * rhs_row_ind, + DMUMPS_COMPLEX * rhs_val, MUMPS_INT rhs_nnz, MUMPS_INT nrhs, + DMUMPS_COMPLEX * x, MUMPS_INT x_length): + """ + Solve a linear system after the LU (or LDL^t) factorization has previously been performed by `factorize` + + Args: + rhs_length: Length of each column of the ``rhs``. + nrhs: Number of columns in the matrix ``rhs``. + overwrite_rhs : ``True`` or ``False`` + whether the data in ``rhs`` may be overwritten, which can lead to a small + performance gain. Default is ``False``. + x : the solution to the linear system as a dense matrix or vector. + x_length: ``self.nrow`` (sequential version). + + Warning: + MUMPS overwrites ``rhs`` and replaces it by the solution of the linear system. + + """ + self.params.nz_rhs = rhs_nnz + self.params.nrhs = nrhs # nrhs -1 ? + + self.params.rhs_sparse = rhs_val + self.params.irhs_sparse = rhs_row_ind + self.params.irhs_ptr = rhs_col_ptr + + # MUMPS places the solution(s) of the linear system in its dense rhs... + self.params.lrhs = x_length + self.params.rhs = x + + self.params.job = 3 # solve + self.icntl[20] = 1 # tell solver rhs is sparse + self.mumps_call() + + def solve(self, **kwargs): + """ + + Args: + rhs: dense NumPy array (matrix or vector). + rhs_col_ptr, rhs_row_ind, rhs_val: sparse NumPy CSC arrays (matrix or vector). + transpose_solve : ``True`` or ``False`` whether to solve A * x = rhs or A^T * x = rhs. Default is ``False`` + + Returns: + Dense NumPy array ``x`` (matrix or vector) with the solution(s) of the linear system. + """ + if not self.factorized: + self.factorize() + + transpose_solve = kwargs.get('transpose_solve', False) + self.icntl[9] = 2 if transpose_solve else 1 + + cdef: + MUMPS_INT nrhs + + # rhs can be dense or sparse + if 'rhs' in kwargs: + rhs = kwargs['rhs'] + + if not cnp.PyArray_Check(rhs): + raise TypeError('rhs dense arrays must be an NumPy array') + + # check is dimensions are OK + rhs_shape = rhs.shape + + if (rhs_shape[0] != self.nrow): + raise ValueError("Right hand side has wrong size" + "Attempting to solve the linear system, where A is of size (%d, %d) " + "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + + # create x + x = np.asfortranarray(rhs.copy()) + + # test number of columns in rhs + if rhs.ndim == 1: + nrhs = 1 + else: + nrhs = rhs_shape[1] + + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + + elif all(arg in kwargs for arg in ['rhs_col_ptr', 'rhs_row_ind', 'rhs_val']) : + + rhs_col_ptr = kwargs['rhs_col_ptr'] + rhs_row_ind = kwargs['rhs_row_ind'] + rhs_val = kwargs['rhs_val'] + + # fortran indices, done internally in C: no efficiency lost + rhs_col_ptr += 1 + rhs_row_ind += 1 + + nrhs = rhs_col_ptr.size - 1 + x_length = self.nrow + rhs_nnz = rhs_val.size + + x = np.zeros([self.nrow, nrhs], dtype=np.float64) + + self.solve_sparse(cnp.PyArray_DATA(rhs_col_ptr), cnp.PyArray_DATA(rhs_row_ind), + cnp.PyArray_DATA(rhs_val), + rhs_nnz, nrhs, cnp.PyArray_DATA(x), x_length) + else: + raise TypeError('rhs not given in the right format (dense: rhs=..., sparse: rhs_col_ptr=..., rhs_row_ind=..., rhs_val=...)') + + return x + + def refine(self, rhs, nitref = 3, tol=None): + """ + refine(rhs, nitref) performs iterative refinement if necessary + until the scaled residual norm ||b-Ax||/(1+||b||) falls below the + threshold 'tol' or until nitref steps are taken. + Parameters: + nitref : < 0 : Fixed number of steps of iterative refinement. No stopping criterion is used. + 0 : No iterative refinement. + > 0 : Maximum number of steps of iterative refinement. A stopping criterion is used, + therefore a test for convergence is done at each step of the iterative refinement algorithm. + Default: 3 + tol : is the stopping criterion for iterative refinement + + Make sure you have called `solve()` with the same right-hand + side rhs before calling `refine()`. + The residual vector self.residual will be updated to reflect + the updated approximate solution. + """ + cdef: + cnp.npy_intp dim[1] + + if not cnp.PyArray_Check(rhs): + raise TypeError('rhs dense arrays must be an NumPy array') + + # check is dimensions are OK + rhs_shape = rhs.shape + + if (rhs_shape[0] != self.nrow): + raise ValueError("Right hand side has wrong size" + "Attempting to solve the linear system, where A is of size (%d, %d) " + "and rhs is of size (%g)"%(self.nrow, self.nrow, rhs_shape)) + + # test number of columns in rhs. + # Only one rhs is allowed when dense rhs is provided + if rhs.ndim == 1: + nrhs = 1 + else: + raise TypeError("Only one dense rhs is allowed for performing an iterative"+ + "refinement.") + + # create x + x = np.asfortranarray(rhs.copy()) + + self.icntl[10] = nitref + if tol is None: + self.cntl[2] = 0 + else: + self.cntl[2] = tol + + self.solve_dense( cnp.PyArray_DATA(x), rhs_shape[0], nrhs) + + # reset to default values + self.icntl[10] = 0 + self.cntl[2] = -1 + + return x \ No newline at end of file diff --git a/mumps/src/numpy_mumps.cpd b/mumps/src/numpy_mumps.cpd deleted file mode 100644 index bf86206..0000000 --- a/mumps/src/numpy_mumps.cpd +++ /dev/null @@ -1,13 +0,0 @@ -from mumps.src.mumps_@index@_@type@ cimport BaseMUMPSSolver_@index@_@type@, c_to_fortran_index_array, MUMPS_INT -from mumps.src.mumps_@index@_@type@ cimport @type|generic_to_mumps_type|upper@MUMPS_COMPLEX - -import numpy as np -cimport numpy as cnp - -cnp.import_array() - - -cdef class NumpyMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): - cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, - cnp.ndarray[MUMPS_INT, ndim=1] acol, - cnp.ndarray[@type|generic_to_mumps_type|upper@MUMPS_COMPLEX, ndim=1] aval) diff --git a/mumps/src/numpy_mumps_INT32_COMPLEX128.c b/mumps/src/numpy_mumps_INT32_COMPLEX128.c new file mode 100644 index 0000000..1484750 --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_COMPLEX128.c @@ -0,0 +1,6978 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__numpy_mumps_INT32_COMPLEX128 +#define __PYX_HAVE_API__mumps__src__numpy_mumps_INT32_COMPLEX128 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "zmumps_c.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx", + "__init__.pxd", + "type.pxd", + "mumps/src/mumps_INT32_COMPLEX128.pxd", +}; +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; +struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class zmumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":135 + * int ub + * + * cdef get_array(self, ZMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":113 + * cdef void zmumps_c(ZMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class zmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_vtab; + ZMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_COMPLEX128: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + ZMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + ZMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/numpy_mumps_INT32_COMPLEX128.pxd":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_COMPLEX128(BaseMUMPSSolver_INT32_COMPLEX128): # <<<<<<<<<<<<<< + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + */ +struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 { + struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 __pyx_base; +}; + + + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":113 + * cdef void zmumps_c(ZMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array *__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class zmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *, ZMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_22mumps_INT32_COMPLEX128_17zmumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array *__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array; + + +/* "mumps/src/mumps_INT32_COMPLEX128.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_COMPLEX128: # <<<<<<<<<<<<<< + * cdef: + * + */ + +struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, MUMPS_INT *, MUMPS_INT *, ZMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, ZMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *, MUMPS_INT *, MUMPS_INT *, ZMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, ZMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + + +/* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_COMPLEX128(BaseMUMPSSolver_INT32_COMPLEX128): # <<<<<<<<<<<<<< + * """ + * MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 { + struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 __pyx_base; + PyObject *(*get_matrix_data)(struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *__pyx_vtabptr_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +static CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc); + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse); + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc); + +static void* __Pyx_GetVtable(PyObject *dict); + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0}; +static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static int __Pyx_check_binary_version(void); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_get_matrix_data(struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'mumps.src.mumps_INT32_COMPLEX128' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 = 0; +static PyObject *(*__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_c_to_fortran_index_array)(MUMPS_INT *, MUMPS_INT); /*proto*/ + +/* Module declarations from 'mumps.src.numpy_mumps_INT32_COMPLEX128' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 = 0; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_MUMPS_INT = { "MUMPS_INT", NULL, sizeof(MUMPS_INT), { 0 }, 0, IS_UNSIGNED(MUMPS_INT) ? 'U' : 'I', IS_UNSIGNED(MUMPS_INT), 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_StructField __Pyx_StructFields_nn_ZMUMPS_COMPLEX[] = { + {&__Pyx_TypeInfo_double, "r", offsetof(ZMUMPS_COMPLEX, r)}, + {&__Pyx_TypeInfo_double, "i", offsetof(ZMUMPS_COMPLEX, i)}, + {NULL, NULL, 0} +}; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_ZMUMPS_COMPLEX = { "ZMUMPS_COMPLEX", __Pyx_StructFields_nn_ZMUMPS_COMPLEX, sizeof(ZMUMPS_COMPLEX), { 0 }, 0, 'C', 0, 0 }; +#define __Pyx_MODULE_NAME "mumps.src.numpy_mumps_INT32_COMPLEX128" +int __pyx_module_is_main_mumps__src__numpy_mumps_INT32_COMPLEX128 = 0; + +/* Implementation of 'mumps.src.numpy_mumps_INT32_COMPLEX128' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_RuntimeError; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_acol[] = "acol"; +static char __pyx_k_arow[] = "arow"; +static char __pyx_k_aval[] = "aval"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_get_matrix_data[] = "get_matrix_data"; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_acol; +static PyObject *__pyx_n_s_arow; +static PyObject *__pyx_n_s_aval; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_get_matrix_data; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_verbose; +static int __pyx_pf_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_2get_matrix_data(struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; + +/* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED MUMPS_INT __pyx_v_n; + CYTHON_UNUSED MUMPS_INT __pyx_v_nnz; + CYTHON_UNUSED PyObject *__pyx_v_comm_fortran = 0; + CYTHON_UNUSED PyObject *__pyx_v_sym = 0; + CYTHON_UNUSED PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":23 + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX128.NumpyMUMPSSolver_INT32_COMPLEX128.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128___cinit__(((struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[ZMUMPS_COMPLEX, ndim=1] aval): + */ + +static PyObject *__pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_get_matrix_data(struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[2]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_ZMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_matrix_data); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_3get_matrix_data)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_arow)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_arow)); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_arow)); + __Pyx_INCREF(((PyObject *)__pyx_v_acol)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_acol)); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, ((PyObject *)__pyx_v_acol)); + __Pyx_INCREF(((PyObject *)__pyx_v_aval)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_aval)); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, ((PyObject *)__pyx_v_aval)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":50 + * """ + * + * assert arow.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_arow->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":51 + * + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert aval.shape[0] == self.nnz + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_acol->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":52 + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz # <<<<<<<<<<<<<< + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_aval->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":54 + * assert aval.shape[0] == self.nnz + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(acol), + * cnp.PyArray_DATA(aval)) + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_data_pointers(((struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_arow))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_acol))), ((ZMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_aval)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[ZMUMPS_COMPLEX, ndim=1] aval): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX128.NumpyMUMPSSolver_INT32_COMPLEX128.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_2get_matrix_data[] = "\n\n Args:\n arow: row indices of non zero elements of A\n acol: column indices of non zero elements of A\n aval: values of non zeros elements of A\n\n Note: we keep the same name for this method in all derived classes.\n "; +static PyObject *__pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_arow = 0; + PyArrayObject *__pyx_v_acol = 0; + PyArrayObject *__pyx_v_aval = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_matrix_data (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arow,&__pyx_n_s_acol,&__pyx_n_s_aval,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arow)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acol)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_aval)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_matrix_data") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_arow = ((PyArrayObject *)values[0]); + __pyx_v_acol = ((PyArrayObject *)values[1]); + __pyx_v_aval = ((PyArrayObject *)values[2]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX128.NumpyMUMPSSolver_INT32_COMPLEX128.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arow), __pyx_ptype_5numpy_ndarray, 1, "arow", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_acol), __pyx_ptype_5numpy_ndarray, 1, "acol", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_aval), __pyx_ptype_5numpy_ndarray, 1, "aval", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_r = __pyx_pf_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_2get_matrix_data(((struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *)__pyx_v_self), __pyx_v_arow, __pyx_v_acol, __pyx_v_aval); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_2get_matrix_data(struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[2]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_ZMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_get_matrix_data(__pyx_v_self, ((PyArrayObject *)__pyx_v_arow), ((PyArrayObject *)__pyx_v_acol), ((PyArrayObject *)__pyx_v_aval), 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX128.NumpyMUMPSSolver_INT32_COMPLEX128.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 __pyx_vtable_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128; + +static PyObject *__pyx_tp_new_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *p; + PyObject *o = __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128->tp_new(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128*)__pyx_vtabptr_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128; + if (unlikely(__pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + PyObject_GC_Track(o); + if (likely(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128)) __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128); +} + +static int __pyx_tp_traverse_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128(PyObject *o, visitproc v, void *a) { + int e; + e = ((likely(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128)) ? ((__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128->tp_traverse) ? __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128)); if (e) return e; + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128(PyObject *o) { + if (likely(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128)) { if (__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128->tp_clear) __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128); + return 0; +} + +static PyMethodDef __pyx_methods_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128[] = { + {"get_matrix_data", (PyCFunction)__pyx_pw_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_3get_matrix_data, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_2get_matrix_data}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.numpy_mumps_INT32_COMPLEX128.NumpyMUMPSSolver_INT32_COMPLEX128", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n MUMPS Context.\n\n Only deals with Numpy arrays.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n\n Warning: if the numpy arrays are modified externally by the user between 2 calls to solve,\n the changes in arrays won't be passed to MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "numpy_mumps_INT32_COMPLEX128", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_acol, __pyx_k_acol, sizeof(__pyx_k_acol), 0, 0, 1, 1}, + {&__pyx_n_s_arow, __pyx_k_arow, sizeof(__pyx_k_arow), 0, 0, 1, 1}, + {&__pyx_n_s_aval, __pyx_k_aval, sizeof(__pyx_k_aval), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_get_matrix_data, __pyx_k_get_matrix_data, sizeof(__pyx_k_get_matrix_data), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initnumpy_mumps_INT32_COMPLEX128(void); /*proto*/ +PyMODINIT_FUNC initnumpy_mumps_INT32_COMPLEX128(void) +#else +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_COMPLEX128(void); /*proto*/ +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_COMPLEX128(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_numpy_mumps_INT32_COMPLEX128(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("numpy_mumps_INT32_COMPLEX128", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__numpy_mumps_INT32_COMPLEX128) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.numpy_mumps_INT32_COMPLEX128")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.numpy_mumps_INT32_COMPLEX128", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 = __Pyx_ImportType("mumps.src.mumps_INT32_COMPLEX128", "BaseMUMPSSolver_INT32_COMPLEX128", sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128), 1); if (unlikely(!__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128 = (struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 = &__pyx_vtable_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128; + __pyx_vtable_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128.__pyx_base = *__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + __pyx_vtable_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128.get_matrix_data = (PyObject *(*)(struct __pyx_obj_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch))__pyx_f_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_33NumpyMUMPSSolver_INT32_COMPLEX128_get_matrix_data; + __pyx_type_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128.tp_base = __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_BaseMUMPSSolver_INT32_COMPLEX128; + if (PyType_Ready(&__pyx_type_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128.tp_dict, __pyx_vtabptr_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "NumpyMUMPSSolver_INT32_COMPLEX128", (PyObject *)&__pyx_type_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128 = &__pyx_type_5mumps_3src_28numpy_mumps_INT32_COMPLEX128_NumpyMUMPSSolver_INT32_COMPLEX128; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array = __Pyx_ImportType("mumps.src.mumps_INT32_COMPLEX128", "mumps_int_array", sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array = (struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array = __Pyx_ImportType("mumps.src.mumps_INT32_COMPLEX128", "zmumps_real_array", sizeof(struct __pyx_obj_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array = (struct __pyx_vtabstruct_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_22mumps_INT32_COMPLEX128_zmumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + __pyx_t_1 = __Pyx_ImportModule("mumps.src.mumps_INT32_COMPLEX128"); if (!__pyx_t_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_ImportFunction(__pyx_t_1, "c_to_fortran_index_array", (void (**)(void))&__pyx_f_5mumps_3src_22mumps_INT32_COMPLEX128_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":4 + * from mumps.src.mumps_INT32_COMPLEX128 cimport ZMUMPS_COMPLEX + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":7 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * + */ + import_array(); + + /* "mumps/src/numpy_mumps_INT32_COMPLEX128.pyx":1 + * from mumps.src.mumps_INT32_COMPLEX128 cimport BaseMUMPSSolver_INT32_COMPLEX128, c_to_fortran_index_array, MUMPS_INT # <<<<<<<<<<<<<< + * from mumps.src.mumps_INT32_COMPLEX128 cimport ZMUMPS_COMPLEX + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.numpy_mumps_INT32_COMPLEX128", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.numpy_mumps_INT32_COMPLEX128"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE int __Pyx_IsLittleEndian(void) { + unsigned int n = 1; + return *(unsigned char*)(&n) != 0; +} +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t < '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static CYTHON_INLINE PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} +static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static CYTHON_INLINE int __Pyx_GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + if (obj == Py_None || obj == NULL) { + __Pyx_ZeroBuffer(buf); + return 0; + } + buf->buf = NULL; + if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail; + if (buf->ndim != nd) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if ((unsigned)buf->itemsize != dtype->size) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_ZeroBuffer(buf); + return -1; +} +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (info->buf == NULL) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_dealloc != current_tp_dealloc) + type = type->tp_base; + while (type && type->tp_dealloc == current_tp_dealloc) + type = type->tp_base; + if (type) + type->tp_dealloc(obj); +} + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_traverse != current_tp_traverse) + type = type->tp_base; + while (type && type->tp_traverse == current_tp_traverse) + type = type->tp_base; + if (type && type->tp_traverse) + return type->tp_traverse(obj, v, a); + return 0; +} + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_clear != current_tp_clear) + type = type->tp_base; + while (type && type->tp_clear == current_tp_clear) + type = type->tp_base; + if (type && type->tp_clear) + type->tp_clear(obj); +} + +static void* __Pyx_GetVtable(PyObject *dict) { + void* ptr; + PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); + if (!ob) + goto bad; +#if PY_VERSION_HEX >= 0x02070000 + ptr = PyCapsule_GetPointer(ob, 0); +#else + ptr = PyCObject_AsVoidPtr(ob); +#endif + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; } + Py_DECREF(obj); + view->obj = NULL; +} +#endif + + + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportFunction +#define __PYX_HAVE_RT_ImportFunction +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } +#if PY_VERSION_HEX >= 0x02070000 + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); +#else + {const char *desc, *s1, *s2; + desc = (const char *)PyCObject_GetDesc(cobj); + if (!desc) + goto bad; + s1 = desc; s2 = sig; + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + if (*s1 != *s2) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, desc); + goto bad; + } + tmp.p = PyCObject_AsVoidPtr(cobj);} +#endif + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/numpy_mumps_INT32_COMPLEX128.pxd b/mumps/src/numpy_mumps_INT32_COMPLEX128.pxd new file mode 100644 index 0000000..0bebe08 --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_COMPLEX128.pxd @@ -0,0 +1,13 @@ +from mumps.src.mumps_INT32_COMPLEX128 cimport BaseMUMPSSolver_INT32_COMPLEX128, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_COMPLEX128 cimport ZMUMPS_COMPLEX + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + + +cdef class NumpyMUMPSSolver_INT32_COMPLEX128(BaseMUMPSSolver_INT32_COMPLEX128): + cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + cnp.ndarray[MUMPS_INT, ndim=1] acol, + cnp.ndarray[ZMUMPS_COMPLEX, ndim=1] aval) \ No newline at end of file diff --git a/mumps/src/numpy_mumps.cpx b/mumps/src/numpy_mumps_INT32_COMPLEX128.pyx similarity index 77% rename from mumps/src/numpy_mumps.cpx rename to mumps/src/numpy_mumps_INT32_COMPLEX128.pyx index 329d96f..ac7e34e 100644 --- a/mumps/src/numpy_mumps.cpx +++ b/mumps/src/numpy_mumps_INT32_COMPLEX128.pyx @@ -1,5 +1,5 @@ -from mumps.src.mumps_@index@_@type@ cimport BaseMUMPSSolver_@index@_@type@, c_to_fortran_index_array, MUMPS_INT -from mumps.src.mumps_@index@_@type@ cimport @type|generic_to_mumps_type|upper@MUMPS_COMPLEX +from mumps.src.mumps_INT32_COMPLEX128 cimport BaseMUMPSSolver_INT32_COMPLEX128, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_COMPLEX128 cimport ZMUMPS_COMPLEX import numpy as np cimport numpy as cnp @@ -7,7 +7,7 @@ cimport numpy as cnp cnp.import_array() -cdef class NumpyMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): +cdef class NumpyMUMPSSolver_INT32_COMPLEX128(BaseMUMPSSolver_INT32_COMPLEX128): """ MUMPS Context. @@ -36,7 +36,7 @@ cdef class NumpyMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, cnp.ndarray[MUMPS_INT, ndim=1] acol, - cnp.ndarray[@type|generic_to_mumps_type|upper@MUMPS_COMPLEX, ndim=1] aval): + cnp.ndarray[ZMUMPS_COMPLEX, ndim=1] aval): """ Args: @@ -53,4 +53,4 @@ cdef class NumpyMUMPSSolver_@index@_@type@(BaseMUMPSSolver_@index@_@type@): self.get_data_pointers( cnp.PyArray_DATA(arow), cnp.PyArray_DATA(acol), - <@type|generic_to_mumps_type|upper@MUMPS_COMPLEX *> cnp.PyArray_DATA(aval)) + cnp.PyArray_DATA(aval)) \ No newline at end of file diff --git a/mumps/src/numpy_mumps_INT32_COMPLEX64.c b/mumps/src/numpy_mumps_INT32_COMPLEX64.c new file mode 100644 index 0000000..b0618bc --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_COMPLEX64.c @@ -0,0 +1,6978 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__numpy_mumps_INT32_COMPLEX64 +#define __PYX_HAVE_API__mumps__src__numpy_mumps_INT32_COMPLEX64 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "cmumps_c.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx", + "__init__.pxd", + "type.pxd", + "mumps/src/mumps_INT32_COMPLEX64.pxd", +}; +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; +struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class cmumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":135 + * int ub + * + * cdef get_array(self, CMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":113 + * cdef void cmumps_c(CMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class cmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_vtab; + CMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_COMPLEX64: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + CMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + CMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/numpy_mumps_INT32_COMPLEX64.pxd":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_COMPLEX64(BaseMUMPSSolver_INT32_COMPLEX64): # <<<<<<<<<<<<<< + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + */ +struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 { + struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 __pyx_base; +}; + + + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":113 + * cdef void cmumps_c(CMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array *__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class cmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *, CMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_21mumps_INT32_COMPLEX64_17cmumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array *__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array; + + +/* "mumps/src/mumps_INT32_COMPLEX64.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_COMPLEX64: # <<<<<<<<<<<<<< + * cdef: + * + */ + +struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, MUMPS_INT *, MUMPS_INT *, CMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, CMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *, MUMPS_INT *, MUMPS_INT *, CMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, CMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + + +/* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_COMPLEX64(BaseMUMPSSolver_INT32_COMPLEX64): # <<<<<<<<<<<<<< + * """ + * MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 { + struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 __pyx_base; + PyObject *(*get_matrix_data)(struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *__pyx_vtabptr_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +static CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc); + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse); + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc); + +static void* __Pyx_GetVtable(PyObject *dict); + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0}; +static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static int __Pyx_check_binary_version(void); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_get_matrix_data(struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'mumps.src.mumps_INT32_COMPLEX64' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 = 0; +static PyObject *(*__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_c_to_fortran_index_array)(MUMPS_INT *, MUMPS_INT); /*proto*/ + +/* Module declarations from 'mumps.src.numpy_mumps_INT32_COMPLEX64' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 = 0; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_MUMPS_INT = { "MUMPS_INT", NULL, sizeof(MUMPS_INT), { 0 }, 0, IS_UNSIGNED(MUMPS_INT) ? 'U' : 'I', IS_UNSIGNED(MUMPS_INT), 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; +static __Pyx_StructField __Pyx_StructFields_nn_CMUMPS_COMPLEX[] = { + {&__Pyx_TypeInfo_float, "r", offsetof(CMUMPS_COMPLEX, r)}, + {&__Pyx_TypeInfo_float, "i", offsetof(CMUMPS_COMPLEX, i)}, + {NULL, NULL, 0} +}; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_CMUMPS_COMPLEX = { "CMUMPS_COMPLEX", __Pyx_StructFields_nn_CMUMPS_COMPLEX, sizeof(CMUMPS_COMPLEX), { 0 }, 0, 'C', 0, 0 }; +#define __Pyx_MODULE_NAME "mumps.src.numpy_mumps_INT32_COMPLEX64" +int __pyx_module_is_main_mumps__src__numpy_mumps_INT32_COMPLEX64 = 0; + +/* Implementation of 'mumps.src.numpy_mumps_INT32_COMPLEX64' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_RuntimeError; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_acol[] = "acol"; +static char __pyx_k_arow[] = "arow"; +static char __pyx_k_aval[] = "aval"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_get_matrix_data[] = "get_matrix_data"; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_acol; +static PyObject *__pyx_n_s_arow; +static PyObject *__pyx_n_s_aval; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_get_matrix_data; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_verbose; +static int __pyx_pf_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_2get_matrix_data(struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; + +/* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED MUMPS_INT __pyx_v_n; + CYTHON_UNUSED MUMPS_INT __pyx_v_nnz; + CYTHON_UNUSED PyObject *__pyx_v_comm_fortran = 0; + CYTHON_UNUSED PyObject *__pyx_v_sym = 0; + CYTHON_UNUSED PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":23 + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX64.NumpyMUMPSSolver_INT32_COMPLEX64.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64___cinit__(((struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[CMUMPS_COMPLEX, ndim=1] aval): + */ + +static PyObject *__pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_get_matrix_data(struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[2]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_CMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_matrix_data); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_3get_matrix_data)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_arow)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_arow)); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_arow)); + __Pyx_INCREF(((PyObject *)__pyx_v_acol)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_acol)); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, ((PyObject *)__pyx_v_acol)); + __Pyx_INCREF(((PyObject *)__pyx_v_aval)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_aval)); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, ((PyObject *)__pyx_v_aval)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":50 + * """ + * + * assert arow.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_arow->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":51 + * + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert aval.shape[0] == self.nnz + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_acol->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":52 + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz # <<<<<<<<<<<<<< + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_aval->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":54 + * assert aval.shape[0] == self.nnz + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(acol), + * cnp.PyArray_DATA(aval)) + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_data_pointers(((struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_arow))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_acol))), ((CMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_aval)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[CMUMPS_COMPLEX, ndim=1] aval): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX64.NumpyMUMPSSolver_INT32_COMPLEX64.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_2get_matrix_data[] = "\n\n Args:\n arow: row indices of non zero elements of A\n acol: column indices of non zero elements of A\n aval: values of non zeros elements of A\n\n Note: we keep the same name for this method in all derived classes.\n "; +static PyObject *__pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_arow = 0; + PyArrayObject *__pyx_v_acol = 0; + PyArrayObject *__pyx_v_aval = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_matrix_data (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arow,&__pyx_n_s_acol,&__pyx_n_s_aval,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arow)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acol)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_aval)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_matrix_data") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_arow = ((PyArrayObject *)values[0]); + __pyx_v_acol = ((PyArrayObject *)values[1]); + __pyx_v_aval = ((PyArrayObject *)values[2]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX64.NumpyMUMPSSolver_INT32_COMPLEX64.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arow), __pyx_ptype_5numpy_ndarray, 1, "arow", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_acol), __pyx_ptype_5numpy_ndarray, 1, "acol", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_aval), __pyx_ptype_5numpy_ndarray, 1, "aval", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_r = __pyx_pf_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_2get_matrix_data(((struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *)__pyx_v_self), __pyx_v_arow, __pyx_v_acol, __pyx_v_aval); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_2get_matrix_data(struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[2]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_CMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_get_matrix_data(__pyx_v_self, ((PyArrayObject *)__pyx_v_arow), ((PyArrayObject *)__pyx_v_acol), ((PyArrayObject *)__pyx_v_aval), 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_COMPLEX64.NumpyMUMPSSolver_INT32_COMPLEX64.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 __pyx_vtable_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64; + +static PyObject *__pyx_tp_new_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *p; + PyObject *o = __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64->tp_new(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64*)__pyx_vtabptr_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64; + if (unlikely(__pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + PyObject_GC_Track(o); + if (likely(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64)) __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64); +} + +static int __pyx_tp_traverse_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64(PyObject *o, visitproc v, void *a) { + int e; + e = ((likely(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64)) ? ((__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64->tp_traverse) ? __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64)); if (e) return e; + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64(PyObject *o) { + if (likely(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64)) { if (__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64->tp_clear) __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64); + return 0; +} + +static PyMethodDef __pyx_methods_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64[] = { + {"get_matrix_data", (PyCFunction)__pyx_pw_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_3get_matrix_data, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_2get_matrix_data}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.numpy_mumps_INT32_COMPLEX64.NumpyMUMPSSolver_INT32_COMPLEX64", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n MUMPS Context.\n\n Only deals with Numpy arrays.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n\n Warning: if the numpy arrays are modified externally by the user between 2 calls to solve,\n the changes in arrays won't be passed to MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "numpy_mumps_INT32_COMPLEX64", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_acol, __pyx_k_acol, sizeof(__pyx_k_acol), 0, 0, 1, 1}, + {&__pyx_n_s_arow, __pyx_k_arow, sizeof(__pyx_k_arow), 0, 0, 1, 1}, + {&__pyx_n_s_aval, __pyx_k_aval, sizeof(__pyx_k_aval), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_get_matrix_data, __pyx_k_get_matrix_data, sizeof(__pyx_k_get_matrix_data), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initnumpy_mumps_INT32_COMPLEX64(void); /*proto*/ +PyMODINIT_FUNC initnumpy_mumps_INT32_COMPLEX64(void) +#else +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_COMPLEX64(void); /*proto*/ +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_COMPLEX64(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_numpy_mumps_INT32_COMPLEX64(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("numpy_mumps_INT32_COMPLEX64", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__numpy_mumps_INT32_COMPLEX64) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.numpy_mumps_INT32_COMPLEX64")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.numpy_mumps_INT32_COMPLEX64", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 = __Pyx_ImportType("mumps.src.mumps_INT32_COMPLEX64", "BaseMUMPSSolver_INT32_COMPLEX64", sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64), 1); if (unlikely(!__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64 = (struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 = &__pyx_vtable_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64; + __pyx_vtable_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64.__pyx_base = *__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + __pyx_vtable_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64.get_matrix_data = (PyObject *(*)(struct __pyx_obj_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch))__pyx_f_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_32NumpyMUMPSSolver_INT32_COMPLEX64_get_matrix_data; + __pyx_type_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64.tp_base = __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_BaseMUMPSSolver_INT32_COMPLEX64; + if (PyType_Ready(&__pyx_type_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64.tp_dict, __pyx_vtabptr_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "NumpyMUMPSSolver_INT32_COMPLEX64", (PyObject *)&__pyx_type_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64 = &__pyx_type_5mumps_3src_27numpy_mumps_INT32_COMPLEX64_NumpyMUMPSSolver_INT32_COMPLEX64; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array = __Pyx_ImportType("mumps.src.mumps_INT32_COMPLEX64", "mumps_int_array", sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array = (struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array = __Pyx_ImportType("mumps.src.mumps_INT32_COMPLEX64", "cmumps_real_array", sizeof(struct __pyx_obj_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array = (struct __pyx_vtabstruct_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_21mumps_INT32_COMPLEX64_cmumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + __pyx_t_1 = __Pyx_ImportModule("mumps.src.mumps_INT32_COMPLEX64"); if (!__pyx_t_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_ImportFunction(__pyx_t_1, "c_to_fortran_index_array", (void (**)(void))&__pyx_f_5mumps_3src_21mumps_INT32_COMPLEX64_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":4 + * from mumps.src.mumps_INT32_COMPLEX64 cimport CMUMPS_COMPLEX + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":7 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * + */ + import_array(); + + /* "mumps/src/numpy_mumps_INT32_COMPLEX64.pyx":1 + * from mumps.src.mumps_INT32_COMPLEX64 cimport BaseMUMPSSolver_INT32_COMPLEX64, c_to_fortran_index_array, MUMPS_INT # <<<<<<<<<<<<<< + * from mumps.src.mumps_INT32_COMPLEX64 cimport CMUMPS_COMPLEX + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.numpy_mumps_INT32_COMPLEX64", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.numpy_mumps_INT32_COMPLEX64"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE int __Pyx_IsLittleEndian(void) { + unsigned int n = 1; + return *(unsigned char*)(&n) != 0; +} +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t < '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static CYTHON_INLINE PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} +static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static CYTHON_INLINE int __Pyx_GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + if (obj == Py_None || obj == NULL) { + __Pyx_ZeroBuffer(buf); + return 0; + } + buf->buf = NULL; + if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail; + if (buf->ndim != nd) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if ((unsigned)buf->itemsize != dtype->size) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_ZeroBuffer(buf); + return -1; +} +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (info->buf == NULL) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_dealloc != current_tp_dealloc) + type = type->tp_base; + while (type && type->tp_dealloc == current_tp_dealloc) + type = type->tp_base; + if (type) + type->tp_dealloc(obj); +} + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_traverse != current_tp_traverse) + type = type->tp_base; + while (type && type->tp_traverse == current_tp_traverse) + type = type->tp_base; + if (type && type->tp_traverse) + return type->tp_traverse(obj, v, a); + return 0; +} + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_clear != current_tp_clear) + type = type->tp_base; + while (type && type->tp_clear == current_tp_clear) + type = type->tp_base; + if (type && type->tp_clear) + type->tp_clear(obj); +} + +static void* __Pyx_GetVtable(PyObject *dict) { + void* ptr; + PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); + if (!ob) + goto bad; +#if PY_VERSION_HEX >= 0x02070000 + ptr = PyCapsule_GetPointer(ob, 0); +#else + ptr = PyCObject_AsVoidPtr(ob); +#endif + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; } + Py_DECREF(obj); + view->obj = NULL; +} +#endif + + + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportFunction +#define __PYX_HAVE_RT_ImportFunction +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } +#if PY_VERSION_HEX >= 0x02070000 + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); +#else + {const char *desc, *s1, *s2; + desc = (const char *)PyCObject_GetDesc(cobj); + if (!desc) + goto bad; + s1 = desc; s2 = sig; + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + if (*s1 != *s2) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, desc); + goto bad; + } + tmp.p = PyCObject_AsVoidPtr(cobj);} +#endif + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/numpy_mumps_INT32_COMPLEX64.pxd b/mumps/src/numpy_mumps_INT32_COMPLEX64.pxd new file mode 100644 index 0000000..be65d0d --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_COMPLEX64.pxd @@ -0,0 +1,13 @@ +from mumps.src.mumps_INT32_COMPLEX64 cimport BaseMUMPSSolver_INT32_COMPLEX64, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_COMPLEX64 cimport CMUMPS_COMPLEX + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + + +cdef class NumpyMUMPSSolver_INT32_COMPLEX64(BaseMUMPSSolver_INT32_COMPLEX64): + cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + cnp.ndarray[MUMPS_INT, ndim=1] acol, + cnp.ndarray[CMUMPS_COMPLEX, ndim=1] aval) \ No newline at end of file diff --git a/mumps/src/numpy_mumps_INT32_COMPLEX64.pyx b/mumps/src/numpy_mumps_INT32_COMPLEX64.pyx new file mode 100644 index 0000000..f5720b3 --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_COMPLEX64.pyx @@ -0,0 +1,56 @@ +from mumps.src.mumps_INT32_COMPLEX64 cimport BaseMUMPSSolver_INT32_COMPLEX64, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_COMPLEX64 cimport CMUMPS_COMPLEX + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + + +cdef class NumpyMUMPSSolver_INT32_COMPLEX64(BaseMUMPSSolver_INT32_COMPLEX64): + """ + MUMPS Context. + + Only deals with Numpy arrays. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + + Warning: if the numpy arrays are modified externally by the user between 2 calls to solve, + the changes in arrays won't be passed to MUMPS. + """ + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + + Warning: if the numpy arrays are modified externally by the user between 2 calls to solve, + the changes in arrays won't be passed to MUMPS. + """ + pass + + cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + cnp.ndarray[MUMPS_INT, ndim=1] acol, + cnp.ndarray[CMUMPS_COMPLEX, ndim=1] aval): + """ + + Args: + arow: row indices of non zero elements of A + acol: column indices of non zero elements of A + aval: values of non zeros elements of A + + Note: we keep the same name for this method in all derived classes. + """ + + assert arow.shape[0] == self.nnz + assert acol.shape[0] == self.nnz + assert aval.shape[0] == self.nnz + + self.get_data_pointers( cnp.PyArray_DATA(arow), + cnp.PyArray_DATA(acol), + cnp.PyArray_DATA(aval)) \ No newline at end of file diff --git a/mumps/src/numpy_mumps_INT32_FLOAT32.c b/mumps/src/numpy_mumps_INT32_FLOAT32.c new file mode 100644 index 0000000..7fcb25a --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_FLOAT32.c @@ -0,0 +1,6972 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__numpy_mumps_INT32_FLOAT32 +#define __PYX_HAVE_API__mumps__src__numpy_mumps_INT32_FLOAT32 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "smumps_c.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/numpy_mumps_INT32_FLOAT32.pyx", + "__init__.pxd", + "type.pxd", + "mumps/src/mumps_INT32_FLOAT32.pxd", +}; +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; +struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class smumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":135 + * int ub + * + * cdef get_array(self, SMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":113 + * cdef void smumps_c(SMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class smumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_vtab; + SMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_FLOAT32: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + SMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + SMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/numpy_mumps_INT32_FLOAT32.pxd":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_FLOAT32(BaseMUMPSSolver_INT32_FLOAT32): # <<<<<<<<<<<<<< + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + */ +struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 __pyx_base; +}; + + + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":113 + * cdef void smumps_c(SMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array; + + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class smumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *, SMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT32_17smumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array; + + +/* "mumps/src/mumps_INT32_FLOAT32.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_FLOAT32: # <<<<<<<<<<<<<< + * cdef: + * + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, MUMPS_INT *, MUMPS_INT *, SMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, SMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *, MUMPS_INT *, MUMPS_INT *, SMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, SMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + + +/* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_FLOAT32(BaseMUMPSSolver_INT32_FLOAT32): # <<<<<<<<<<<<<< + * """ + * MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 { + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 __pyx_base; + PyObject *(*get_matrix_data)(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *__pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +static CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc); + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse); + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc); + +static void* __Pyx_GetVtable(PyObject *dict); + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0}; +static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static int __Pyx_check_binary_version(void); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'mumps.src.mumps_INT32_FLOAT32' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 = 0; +static PyObject *(*__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_c_to_fortran_index_array)(MUMPS_INT *, MUMPS_INT); /*proto*/ + +/* Module declarations from 'mumps.src.numpy_mumps_INT32_FLOAT32' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 = 0; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_MUMPS_INT = { "MUMPS_INT", NULL, sizeof(MUMPS_INT), { 0 }, 0, IS_UNSIGNED(MUMPS_INT) ? 'U' : 'I', IS_UNSIGNED(MUMPS_INT), 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_SMUMPS_COMPLEX = { "SMUMPS_COMPLEX", NULL, sizeof(SMUMPS_COMPLEX), { 0 }, 0, 'R', 0, 0 }; +#define __Pyx_MODULE_NAME "mumps.src.numpy_mumps_INT32_FLOAT32" +int __pyx_module_is_main_mumps__src__numpy_mumps_INT32_FLOAT32 = 0; + +/* Implementation of 'mumps.src.numpy_mumps_INT32_FLOAT32' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_RuntimeError; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_acol[] = "acol"; +static char __pyx_k_arow[] = "arow"; +static char __pyx_k_aval[] = "aval"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_get_matrix_data[] = "get_matrix_data"; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_acol; +static PyObject *__pyx_n_s_arow; +static PyObject *__pyx_n_s_aval; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_get_matrix_data; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_verbose; +static int __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_2get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; + +/* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED MUMPS_INT __pyx_v_n; + CYTHON_UNUSED MUMPS_INT __pyx_v_nnz; + CYTHON_UNUSED PyObject *__pyx_v_comm_fortran = 0; + CYTHON_UNUSED PyObject *__pyx_v_sym = 0; + CYTHON_UNUSED PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":23 + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT32.NumpyMUMPSSolver_INT32_FLOAT32.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32___cinit__(((struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[SMUMPS_COMPLEX, ndim=1] aval): + */ + +static PyObject *__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_SMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_matrix_data); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_3get_matrix_data)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_arow)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_arow)); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_arow)); + __Pyx_INCREF(((PyObject *)__pyx_v_acol)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_acol)); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, ((PyObject *)__pyx_v_acol)); + __Pyx_INCREF(((PyObject *)__pyx_v_aval)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_aval)); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, ((PyObject *)__pyx_v_aval)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":50 + * """ + * + * assert arow.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_arow->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":51 + * + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert aval.shape[0] == self.nnz + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_acol->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":52 + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz # <<<<<<<<<<<<<< + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_aval->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":54 + * assert aval.shape[0] == self.nnz + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(acol), + * cnp.PyArray_DATA(aval)) + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_data_pointers(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_arow))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_acol))), ((SMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_aval)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[SMUMPS_COMPLEX, ndim=1] aval): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT32.NumpyMUMPSSolver_INT32_FLOAT32.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_2get_matrix_data[] = "\n\n Args:\n arow: row indices of non zero elements of A\n acol: column indices of non zero elements of A\n aval: values of non zeros elements of A\n\n Note: we keep the same name for this method in all derived classes.\n "; +static PyObject *__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_arow = 0; + PyArrayObject *__pyx_v_acol = 0; + PyArrayObject *__pyx_v_aval = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_matrix_data (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arow,&__pyx_n_s_acol,&__pyx_n_s_aval,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arow)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acol)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_aval)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_matrix_data") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_arow = ((PyArrayObject *)values[0]); + __pyx_v_acol = ((PyArrayObject *)values[1]); + __pyx_v_aval = ((PyArrayObject *)values[2]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT32.NumpyMUMPSSolver_INT32_FLOAT32.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arow), __pyx_ptype_5numpy_ndarray, 1, "arow", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_acol), __pyx_ptype_5numpy_ndarray, 1, "acol", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_aval), __pyx_ptype_5numpy_ndarray, 1, "aval", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_r = __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_2get_matrix_data(((struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *)__pyx_v_self), __pyx_v_arow, __pyx_v_acol, __pyx_v_aval); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_2get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_SMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_get_matrix_data(__pyx_v_self, ((PyArrayObject *)__pyx_v_arow), ((PyArrayObject *)__pyx_v_acol), ((PyArrayObject *)__pyx_v_aval), 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT32.NumpyMUMPSSolver_INT32_FLOAT32.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 __pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32; + +static PyObject *__pyx_tp_new_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *p; + PyObject *o = __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32->tp_new(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32*)__pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32; + if (unlikely(__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + PyObject_GC_Track(o); + if (likely(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32)) __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32); +} + +static int __pyx_tp_traverse_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32(PyObject *o, visitproc v, void *a) { + int e; + e = ((likely(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32)) ? ((__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32->tp_traverse) ? __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32)); if (e) return e; + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32(PyObject *o) { + if (likely(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32)) { if (__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32->tp_clear) __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32); + return 0; +} + +static PyMethodDef __pyx_methods_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32[] = { + {"get_matrix_data", (PyCFunction)__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_3get_matrix_data, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_2get_matrix_data}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.numpy_mumps_INT32_FLOAT32.NumpyMUMPSSolver_INT32_FLOAT32", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n MUMPS Context.\n\n Only deals with Numpy arrays.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n\n Warning: if the numpy arrays are modified externally by the user between 2 calls to solve,\n the changes in arrays won't be passed to MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "numpy_mumps_INT32_FLOAT32", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_acol, __pyx_k_acol, sizeof(__pyx_k_acol), 0, 0, 1, 1}, + {&__pyx_n_s_arow, __pyx_k_arow, sizeof(__pyx_k_arow), 0, 0, 1, 1}, + {&__pyx_n_s_aval, __pyx_k_aval, sizeof(__pyx_k_aval), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_get_matrix_data, __pyx_k_get_matrix_data, sizeof(__pyx_k_get_matrix_data), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initnumpy_mumps_INT32_FLOAT32(void); /*proto*/ +PyMODINIT_FUNC initnumpy_mumps_INT32_FLOAT32(void) +#else +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_FLOAT32(void); /*proto*/ +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_FLOAT32(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_numpy_mumps_INT32_FLOAT32(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("numpy_mumps_INT32_FLOAT32", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__numpy_mumps_INT32_FLOAT32) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.numpy_mumps_INT32_FLOAT32")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.numpy_mumps_INT32_FLOAT32", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 = __Pyx_ImportType("mumps.src.mumps_INT32_FLOAT32", "BaseMUMPSSolver_INT32_FLOAT32", sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32), 1); if (unlikely(!__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32 = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 = &__pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32; + __pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32.__pyx_base = *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + __pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32.get_matrix_data = (PyObject *(*)(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch))__pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT32_30NumpyMUMPSSolver_INT32_FLOAT32_get_matrix_data; + __pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32.tp_base = __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_BaseMUMPSSolver_INT32_FLOAT32; + if (PyType_Ready(&__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32.tp_dict, __pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "NumpyMUMPSSolver_INT32_FLOAT32", (PyObject *)&__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32 = &__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT32_NumpyMUMPSSolver_INT32_FLOAT32; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array = __Pyx_ImportType("mumps.src.mumps_INT32_FLOAT32", "mumps_int_array", sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array = __Pyx_ImportType("mumps.src.mumps_INT32_FLOAT32", "smumps_real_array", sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT32_smumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + __pyx_t_1 = __Pyx_ImportModule("mumps.src.mumps_INT32_FLOAT32"); if (!__pyx_t_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_ImportFunction(__pyx_t_1, "c_to_fortran_index_array", (void (**)(void))&__pyx_f_5mumps_3src_19mumps_INT32_FLOAT32_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":4 + * from mumps.src.mumps_INT32_FLOAT32 cimport SMUMPS_COMPLEX + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":7 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * + */ + import_array(); + + /* "mumps/src/numpy_mumps_INT32_FLOAT32.pyx":1 + * from mumps.src.mumps_INT32_FLOAT32 cimport BaseMUMPSSolver_INT32_FLOAT32, c_to_fortran_index_array, MUMPS_INT # <<<<<<<<<<<<<< + * from mumps.src.mumps_INT32_FLOAT32 cimport SMUMPS_COMPLEX + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.numpy_mumps_INT32_FLOAT32", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.numpy_mumps_INT32_FLOAT32"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE int __Pyx_IsLittleEndian(void) { + unsigned int n = 1; + return *(unsigned char*)(&n) != 0; +} +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t < '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static CYTHON_INLINE PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} +static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static CYTHON_INLINE int __Pyx_GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + if (obj == Py_None || obj == NULL) { + __Pyx_ZeroBuffer(buf); + return 0; + } + buf->buf = NULL; + if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail; + if (buf->ndim != nd) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if ((unsigned)buf->itemsize != dtype->size) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_ZeroBuffer(buf); + return -1; +} +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (info->buf == NULL) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_dealloc != current_tp_dealloc) + type = type->tp_base; + while (type && type->tp_dealloc == current_tp_dealloc) + type = type->tp_base; + if (type) + type->tp_dealloc(obj); +} + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_traverse != current_tp_traverse) + type = type->tp_base; + while (type && type->tp_traverse == current_tp_traverse) + type = type->tp_base; + if (type && type->tp_traverse) + return type->tp_traverse(obj, v, a); + return 0; +} + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_clear != current_tp_clear) + type = type->tp_base; + while (type && type->tp_clear == current_tp_clear) + type = type->tp_base; + if (type && type->tp_clear) + type->tp_clear(obj); +} + +static void* __Pyx_GetVtable(PyObject *dict) { + void* ptr; + PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); + if (!ob) + goto bad; +#if PY_VERSION_HEX >= 0x02070000 + ptr = PyCapsule_GetPointer(ob, 0); +#else + ptr = PyCObject_AsVoidPtr(ob); +#endif + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; } + Py_DECREF(obj); + view->obj = NULL; +} +#endif + + + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportFunction +#define __PYX_HAVE_RT_ImportFunction +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } +#if PY_VERSION_HEX >= 0x02070000 + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); +#else + {const char *desc, *s1, *s2; + desc = (const char *)PyCObject_GetDesc(cobj); + if (!desc) + goto bad; + s1 = desc; s2 = sig; + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + if (*s1 != *s2) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, desc); + goto bad; + } + tmp.p = PyCObject_AsVoidPtr(cobj);} +#endif + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/numpy_mumps_INT32_FLOAT32.pxd b/mumps/src/numpy_mumps_INT32_FLOAT32.pxd new file mode 100644 index 0000000..e5ecdb1 --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_FLOAT32.pxd @@ -0,0 +1,13 @@ +from mumps.src.mumps_INT32_FLOAT32 cimport BaseMUMPSSolver_INT32_FLOAT32, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_FLOAT32 cimport SMUMPS_COMPLEX + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + + +cdef class NumpyMUMPSSolver_INT32_FLOAT32(BaseMUMPSSolver_INT32_FLOAT32): + cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + cnp.ndarray[MUMPS_INT, ndim=1] acol, + cnp.ndarray[SMUMPS_COMPLEX, ndim=1] aval) \ No newline at end of file diff --git a/mumps/src/numpy_mumps_INT32_FLOAT32.pyx b/mumps/src/numpy_mumps_INT32_FLOAT32.pyx new file mode 100644 index 0000000..467e824 --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_FLOAT32.pyx @@ -0,0 +1,56 @@ +from mumps.src.mumps_INT32_FLOAT32 cimport BaseMUMPSSolver_INT32_FLOAT32, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_FLOAT32 cimport SMUMPS_COMPLEX + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + + +cdef class NumpyMUMPSSolver_INT32_FLOAT32(BaseMUMPSSolver_INT32_FLOAT32): + """ + MUMPS Context. + + Only deals with Numpy arrays. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + + Warning: if the numpy arrays are modified externally by the user between 2 calls to solve, + the changes in arrays won't be passed to MUMPS. + """ + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + + Warning: if the numpy arrays are modified externally by the user between 2 calls to solve, + the changes in arrays won't be passed to MUMPS. + """ + pass + + cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + cnp.ndarray[MUMPS_INT, ndim=1] acol, + cnp.ndarray[SMUMPS_COMPLEX, ndim=1] aval): + """ + + Args: + arow: row indices of non zero elements of A + acol: column indices of non zero elements of A + aval: values of non zeros elements of A + + Note: we keep the same name for this method in all derived classes. + """ + + assert arow.shape[0] == self.nnz + assert acol.shape[0] == self.nnz + assert aval.shape[0] == self.nnz + + self.get_data_pointers( cnp.PyArray_DATA(arow), + cnp.PyArray_DATA(acol), + cnp.PyArray_DATA(aval)) \ No newline at end of file diff --git a/mumps/src/numpy_mumps_INT32_FLOAT64.c b/mumps/src/numpy_mumps_INT32_FLOAT64.c new file mode 100644 index 0000000..3d2340c --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_FLOAT64.c @@ -0,0 +1,6972 @@ +/* Generated by Cython 0.23.4 */ + +#define PY_SSIZE_T_CLEAN +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03020000) + #error Cython requires Python 2.6+ or Python 3.2+. +#else +#define CYTHON_ABI "0_23_4" +#include +#ifndef offsetof +#define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION +#define CYTHON_COMPILING_IN_PYPY 1 +#define CYTHON_COMPILING_IN_CPYTHON 0 +#else +#define CYTHON_COMPILING_IN_PYPY 0 +#define CYTHON_COMPILING_IN_CPYTHON 1 +#endif +#if !defined(CYTHON_USE_PYLONG_INTERNALS) && CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x02070000 +#define CYTHON_USE_PYLONG_INTERNALS 1 +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) +#define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) +#else + #define CYTHON_PEP393_ENABLED 0 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t PyInt_AsLong +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : PyInstanceMethod_New(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if PY_VERSION_HEX >= 0x030500B1 +#define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) +#elif CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; +} __Pyx_PyAsyncMethodsStruct; +#define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) +#else +#define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) + +#ifndef CYTHON_INLINE + #if defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +#if defined(WIN32) || defined(MS_WINDOWS) + #define _USE_MATH_DEFINES +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif + + +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__mumps__src__numpy_mumps_INT32_FLOAT64 +#define __PYX_HAVE_API__mumps__src__numpy_mumps_INT32_FLOAT64 +#include "string.h" +#include "stdio.h" +#include "stdlib.h" +#include "numpy/arrayobject.h" +#include "numpy/ufuncobject.h" +#include "mumps_c_types.h" +#include "dmumps_c.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#ifdef PYREX_WITHOUT_ASSERTIONS +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +typedef struct {PyObject **p; char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) && defined (_M_X64) + #define __Pyx_sst_abs(value) _abs64(value) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyObject_AsSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#if PY_MAJOR_VERSION < 3 +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) +{ + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +#define __Pyx_Py_UNICODE_strlen Py_UNICODE_strlen +#endif +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +#define __Pyx_PyBool_FromLong(b) ((b) ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False)) +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x); +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +#if CYTHON_COMPILING_IN_CPYTHON +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c)); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ + +static PyObject *__pyx_m; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif defined(_Complex_I) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + + +static const char *__pyx_f[] = { + "mumps/src/numpy_mumps_INT32_FLOAT64.pyx", + "__init__.pxd", + "type.pxd", + "mumps/src/mumps_INT32_FLOAT64.pxd", +}; +#define IS_UNSIGNED(type) (((type) -1) > 0) +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":725 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + */ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":726 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t + */ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":727 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * #ctypedef npy_int96 int96_t + */ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":728 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * #ctypedef npy_int96 int96_t + * #ctypedef npy_int128 int128_t + */ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":732 + * #ctypedef npy_int128 int128_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + */ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":733 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t + */ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":734 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * #ctypedef npy_uint96 uint96_t + */ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":735 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * #ctypedef npy_uint96 uint96_t + * #ctypedef npy_uint128 uint128_t + */ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":739 + * #ctypedef npy_uint128 uint128_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t + */ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":740 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t + */ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":749 + * # The int types are mapped a bit surprising -- + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t + */ +typedef npy_long __pyx_t_5numpy_int_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":750 + * # numpy.int corresponds to 'l' and numpy.long to 'q' + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t # <<<<<<<<<<<<<< + * ctypedef npy_longlong longlong_t + * + */ +typedef npy_longlong __pyx_t_5numpy_long_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":751 + * ctypedef npy_long int_t + * ctypedef npy_longlong long_t + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_ulong uint_t + */ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":753 + * ctypedef npy_longlong longlong_t + * + * ctypedef npy_ulong uint_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t + */ +typedef npy_ulong __pyx_t_5numpy_uint_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":754 + * + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * + */ +typedef npy_ulonglong __pyx_t_5numpy_ulong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":755 + * ctypedef npy_ulong uint_t + * ctypedef npy_ulonglong ulong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t + */ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":757 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * + */ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":758 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t + */ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":760 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t + */ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":761 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * + */ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":762 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cfloat cfloat_t + */ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif + + +/*--- Type declarations ---*/ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; +struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":764 + * ctypedef npy_longdouble longdouble_t + * + * ctypedef npy_cfloat cfloat_t # <<<<<<<<<<<<<< + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t + */ +typedef npy_cfloat __pyx_t_5numpy_cfloat_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":765 + * + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t # <<<<<<<<<<<<<< + * ctypedef npy_clongdouble clongdouble_t + * + */ +typedef npy_cdouble __pyx_t_5numpy_cdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":766 + * ctypedef npy_cfloat cfloat_t + * ctypedef npy_cdouble cdouble_t + * ctypedef npy_clongdouble clongdouble_t # <<<<<<<<<<<<<< + * + * ctypedef npy_cdouble complex_t + */ +typedef npy_clongdouble __pyx_t_5numpy_clongdouble_t; + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":768 + * ctypedef npy_clongdouble clongdouble_t + * + * ctypedef npy_cdouble complex_t # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew1(a): + */ +typedef npy_cdouble __pyx_t_5numpy_complex_t; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array; +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array; + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":123 + * int ub + * + * cdef get_array(self, MUMPS_INT * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef class dmumps_real_array: + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":135 + * int ub + * + * cdef get_array(self, DMUMPS_REAL * array, int ub = ?) # <<<<<<<<<<<<<< + * + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + */ +struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array { + int __pyx_n; + int ub; +}; + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":113 + * cdef void dmumps_c(DMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_vtab; + MUMPS_INT *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class dmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_vtab; + DMUMPS_REAL *array; + int ub; +}; + + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_FLOAT64: # <<<<<<<<<<<<<< + * cdef: + * + */ +struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 { + PyObject_HEAD + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_vtab; + MUMPS_INT nrow; + MUMPS_INT ncol; + MUMPS_INT nnz; + DMUMPS_STRUC_C params; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *icntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *info; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *infog; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *cntl; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *rinfo; + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *rinfog; + MUMPS_INT *a_row; + MUMPS_INT *a_col; + DMUMPS_COMPLEX *a_val; + int analyzed; + int factorized; + int out_of_core; + PyObject *analysis_stats; + PyObject *factorize_stats; + PyObject *solve_stats; +}; + + +/* "mumps/src/numpy_mumps_INT32_FLOAT64.pxd":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_FLOAT64(BaseMUMPSSolver_INT32_FLOAT64): # <<<<<<<<<<<<<< + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + */ +struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 { + struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 __pyx_base; +}; + + + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":113 + * cdef void dmumps_c(DMUMPS_STRUC_C *) + * + * cdef class mumps_int_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *, MUMPS_INT *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_15mumps_int_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array; + + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":125 + * cdef get_array(self, MUMPS_INT * array, int ub = ?) + * + * cdef class dmumps_real_array: # <<<<<<<<<<<<<< + * """ + * Internal classes to use x[i] = value and x[i] setters and getters + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array { + PyObject *(*get_array)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *, DMUMPS_REAL *, struct __pyx_opt_args_5mumps_3src_19mumps_INT32_FLOAT64_17dmumps_real_array_get_array *__pyx_optional_args); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array; + + +/* "mumps/src/mumps_INT32_FLOAT64.pxd":139 + * cdef c_to_fortran_index_array(MUMPS_INT * a, MUMPS_INT a_size) + * + * cdef class BaseMUMPSSolver_INT32_FLOAT64: # <<<<<<<<<<<<<< + * cdef: + * + */ + +struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 { + PyObject *(*get_data_pointers)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, MUMPS_INT *, MUMPS_INT *, DMUMPS_COMPLEX *); + PyObject *(*initialize_mumps_struct)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, PyObject *, PyObject *); + PyObject *(*mumps_call)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *); + PyObject *(*set_centralized_assembled_matrix)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *); + PyObject *(*solve_dense)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, DMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT); + PyObject *(*solve_sparse)(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *, MUMPS_INT *, MUMPS_INT *, DMUMPS_COMPLEX *, MUMPS_INT, MUMPS_INT, DMUMPS_COMPLEX *, MUMPS_INT); +}; +static struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + + +/* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":10 + * + * + * cdef class NumpyMUMPSSolver_INT32_FLOAT64(BaseMUMPSSolver_INT32_FLOAT64): # <<<<<<<<<<<<<< + * """ + * MUMPS Context. + */ + +struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 { + struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 __pyx_base; + PyObject *(*get_matrix_data)(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *__pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64; + +/* --- Runtime support code (head) --- */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ + const char* function_name); + +static CYTHON_INLINE int __Pyx_GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb); + +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact); + +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) + PyErr_SetObject(PyExc_KeyError, args); + Py_XDECREF(args); + } + return NULL; + } + Py_INCREF(value); + return value; +} +#else + #define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc); + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse); + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_dealloc); + +static void* __Pyx_GetVtable(PyObject *dict); + +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +typedef struct { + int code_line; + PyCodeObject* code_object; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +static Py_ssize_t __Pyx_zeros[] = {0, 0, 0, 0, 0, 0, 0, 0}; +static Py_ssize_t __Pyx_minusones[] = {-1, -1, -1, -1, -1, -1, -1, -1}; + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *); + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if (defined(_WIN32) || defined(__clang__)) && defined(__cplusplus) && CYTHON_CCOMPLEX + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eqf(a, b) ((a)==(b)) + #define __Pyx_c_sumf(a, b) ((a)+(b)) + #define __Pyx_c_difff(a, b) ((a)-(b)) + #define __Pyx_c_prodf(a, b) ((a)*(b)) + #define __Pyx_c_quotf(a, b) ((a)/(b)) + #define __Pyx_c_negf(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zerof(z) ((z)==(float)0) + #define __Pyx_c_conjf(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_absf(z) (::std::abs(z)) + #define __Pyx_c_powf(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zerof(z) ((z)==0) + #define __Pyx_c_conjf(z) (conjf(z)) + #if 1 + #define __Pyx_c_absf(z) (cabsf(z)) + #define __Pyx_c_powf(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +#if CYTHON_CCOMPLEX + #define __Pyx_c_eq(a, b) ((a)==(b)) + #define __Pyx_c_sum(a, b) ((a)+(b)) + #define __Pyx_c_diff(a, b) ((a)-(b)) + #define __Pyx_c_prod(a, b) ((a)*(b)) + #define __Pyx_c_quot(a, b) ((a)/(b)) + #define __Pyx_c_neg(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero(z) ((z)==(double)0) + #define __Pyx_c_conj(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs(z) (::std::abs(z)) + #define __Pyx_c_pow(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero(z) ((z)==0) + #define __Pyx_c_conj(z) (conj(z)) + #if 1 + #define __Pyx_c_abs(z) (cabs(z)) + #define __Pyx_c_pow(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value); + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +static int __Pyx_check_binary_version(void); + +#if !defined(__Pyx_PyIdentifier_FromString) +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyIdentifier_FromString(s) PyString_FromString(s) +#else + #define __Pyx_PyIdentifier_FromString(s) PyUnicode_FromString(s) +#endif +#endif + +static PyObject *__Pyx_ImportModule(const char *name); + +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, size_t size, int strict); + +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig); + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); + +static PyObject *__pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from 'cpython.buffer' */ + +/* Module declarations from 'libc.string' */ + +/* Module declarations from 'libc.stdio' */ + +/* Module declarations from '__builtin__' */ + +/* Module declarations from 'cpython.type' */ +static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; + +/* Module declarations from 'cpython' */ + +/* Module declarations from 'cpython.object' */ + +/* Module declarations from 'cpython.ref' */ + +/* Module declarations from 'libc.stdlib' */ + +/* Module declarations from 'numpy' */ + +/* Module declarations from 'numpy' */ +static PyTypeObject *__pyx_ptype_5numpy_dtype = 0; +static PyTypeObject *__pyx_ptype_5numpy_flatiter = 0; +static PyTypeObject *__pyx_ptype_5numpy_broadcast = 0; +static PyTypeObject *__pyx_ptype_5numpy_ndarray = 0; +static PyTypeObject *__pyx_ptype_5numpy_ufunc = 0; +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *, char *, char *, int *); /*proto*/ + +/* Module declarations from 'mumps.src.mumps_INT32_FLOAT64' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array = 0; +static PyTypeObject *__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 = 0; +static PyObject *(*__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_c_to_fortran_index_array)(MUMPS_INT *, MUMPS_INT); /*proto*/ + +/* Module declarations from 'mumps.src.numpy_mumps_INT32_FLOAT64' */ +static PyTypeObject *__pyx_ptype_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 = 0; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_MUMPS_INT = { "MUMPS_INT", NULL, sizeof(MUMPS_INT), { 0 }, 0, IS_UNSIGNED(MUMPS_INT) ? 'U' : 'I', IS_UNSIGNED(MUMPS_INT), 0 }; +static __Pyx_TypeInfo __Pyx_TypeInfo_nn_DMUMPS_COMPLEX = { "DMUMPS_COMPLEX", NULL, sizeof(DMUMPS_COMPLEX), { 0 }, 0, 'R', 0, 0 }; +#define __Pyx_MODULE_NAME "mumps.src.numpy_mumps_INT32_FLOAT64" +int __pyx_module_is_main_mumps__src__numpy_mumps_INT32_FLOAT64 = 0; + +/* Implementation of 'mumps.src.numpy_mumps_INT32_FLOAT64' */ +static PyObject *__pyx_builtin_ValueError; +static PyObject *__pyx_builtin_range; +static PyObject *__pyx_builtin_RuntimeError; +static char __pyx_k_B[] = "B"; +static char __pyx_k_H[] = "H"; +static char __pyx_k_I[] = "I"; +static char __pyx_k_L[] = "L"; +static char __pyx_k_O[] = "O"; +static char __pyx_k_Q[] = "Q"; +static char __pyx_k_b[] = "b"; +static char __pyx_k_d[] = "d"; +static char __pyx_k_f[] = "f"; +static char __pyx_k_g[] = "g"; +static char __pyx_k_h[] = "h"; +static char __pyx_k_i[] = "i"; +static char __pyx_k_l[] = "l"; +static char __pyx_k_n[] = "n"; +static char __pyx_k_q[] = "q"; +static char __pyx_k_Zd[] = "Zd"; +static char __pyx_k_Zf[] = "Zf"; +static char __pyx_k_Zg[] = "Zg"; +static char __pyx_k_np[] = "np"; +static char __pyx_k_nnz[] = "nnz"; +static char __pyx_k_sym[] = "sym"; +static char __pyx_k_acol[] = "acol"; +static char __pyx_k_arow[] = "arow"; +static char __pyx_k_aval[] = "aval"; +static char __pyx_k_main[] = "__main__"; +static char __pyx_k_test[] = "__test__"; +static char __pyx_k_numpy[] = "numpy"; +static char __pyx_k_range[] = "range"; +static char __pyx_k_import[] = "__import__"; +static char __pyx_k_verbose[] = "verbose"; +static char __pyx_k_ValueError[] = "ValueError"; +static char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static char __pyx_k_RuntimeError[] = "RuntimeError"; +static char __pyx_k_comm_fortran[] = "comm_fortran"; +static char __pyx_k_get_matrix_data[] = "get_matrix_data"; +static char __pyx_k_ndarray_is_not_C_contiguous[] = "ndarray is not C contiguous"; +static char __pyx_k_unknown_dtype_code_in_numpy_pxd[] = "unknown dtype code in numpy.pxd (%d)"; +static char __pyx_k_Format_string_allocated_too_shor[] = "Format string allocated too short, see comment in numpy.pxd"; +static char __pyx_k_Non_native_byte_order_not_suppor[] = "Non-native byte order not supported"; +static char __pyx_k_ndarray_is_not_Fortran_contiguou[] = "ndarray is not Fortran contiguous"; +static char __pyx_k_Format_string_allocated_too_shor_2[] = "Format string allocated too short."; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor; +static PyObject *__pyx_kp_u_Format_string_allocated_too_shor_2; +static PyObject *__pyx_kp_u_Non_native_byte_order_not_suppor; +static PyObject *__pyx_n_s_RuntimeError; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_acol; +static PyObject *__pyx_n_s_arow; +static PyObject *__pyx_n_s_aval; +static PyObject *__pyx_n_s_comm_fortran; +static PyObject *__pyx_n_s_get_matrix_data; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_n; +static PyObject *__pyx_kp_u_ndarray_is_not_C_contiguous; +static PyObject *__pyx_kp_u_ndarray_is_not_Fortran_contiguou; +static PyObject *__pyx_n_s_nnz; +static PyObject *__pyx_n_s_np; +static PyObject *__pyx_n_s_numpy; +static PyObject *__pyx_n_s_pyx_vtable; +static PyObject *__pyx_n_s_range; +static PyObject *__pyx_n_s_sym; +static PyObject *__pyx_n_s_test; +static PyObject *__pyx_kp_u_unknown_dtype_code_in_numpy_pxd; +static PyObject *__pyx_n_s_verbose; +static int __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose); /* proto */ +static PyObject *__pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_2get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval); /* proto */ +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info); /* proto */ +static PyObject *__pyx_tp_new_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_neg_987654; +static PyObject *__pyx_tuple_; +static PyObject *__pyx_tuple__2; +static PyObject *__pyx_tuple__3; +static PyObject *__pyx_tuple__4; +static PyObject *__pyx_tuple__5; +static PyObject *__pyx_tuple__6; + +/* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + +/* Python wrapper */ +static int __pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED MUMPS_INT __pyx_v_n; + CYTHON_UNUSED MUMPS_INT __pyx_v_nnz; + CYTHON_UNUSED PyObject *__pyx_v_comm_fortran = 0; + CYTHON_UNUSED PyObject *__pyx_v_sym = 0; + CYTHON_UNUSED PyObject *__pyx_v_verbose = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_n,&__pyx_n_s_nnz,&__pyx_n_s_comm_fortran,&__pyx_n_s_sym,&__pyx_n_s_verbose,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[2] = ((PyObject *)__pyx_int_neg_987654); + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":23 + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + * comm_fortran=-987654, sym=False, verbose=False): # <<<<<<<<<<<<<< + * """ + * Args: + */ + values[3] = ((PyObject *)Py_False); + values[4] = ((PyObject *)Py_False); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_n)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_nnz)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_comm_fortran); + if (value) { values[2] = value; kw_args--; } + } + case 3: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_sym); + if (value) { values[3] = value; kw_args--; } + } + case 4: + if (kw_args > 0) { + PyObject* value = PyDict_GetItem(__pyx_kwds, __pyx_n_s_verbose); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_n = __Pyx_PyInt_As_MUMPS_INT(values[0]); if (unlikely((__pyx_v_n == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_nnz = __Pyx_PyInt_As_MUMPS_INT(values[1]); if (unlikely((__pyx_v_nnz == (MUMPS_INT)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_v_comm_fortran = values[2]; + __pyx_v_sym = values[3]; + __pyx_v_verbose = values[4]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 5, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 22; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT64.NumpyMUMPSSolver_INT32_FLOAT64.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64___cinit__(((struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), __pyx_v_n, __pyx_v_nnz, __pyx_v_comm_fortran, __pyx_v_sym, __pyx_v_verbose); + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":22 + * the changes in arrays won't be passed to MUMPS. + * """ + * def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, # <<<<<<<<<<<<<< + * comm_fortran=-987654, sym=False, verbose=False): + * """ + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64___cinit__(CYTHON_UNUSED struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, CYTHON_UNUSED MUMPS_INT __pyx_v_n, CYTHON_UNUSED MUMPS_INT __pyx_v_nnz, CYTHON_UNUSED PyObject *__pyx_v_comm_fortran, CYTHON_UNUSED PyObject *__pyx_v_sym, CYTHON_UNUSED PyObject *__pyx_v_verbose) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[DMUMPS_COMPLEX, ndim=1] aval): + */ + +static PyObject *__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval, int __pyx_skip_dispatch) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_DMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if (unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0)) { + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_get_matrix_data); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + if (!PyCFunction_Check(__pyx_t_1) || (PyCFunction_GET_FUNCTION(__pyx_t_1) != (PyCFunction)__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_3get_matrix_data)) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_3 = __pyx_t_1; __pyx_t_4 = NULL; + __pyx_t_5 = 0; + if (CYTHON_COMPILING_IN_CPYTHON && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_4)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; + } + } + __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + if (__pyx_t_4) { + __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; + } + __Pyx_INCREF(((PyObject *)__pyx_v_arow)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_arow)); + PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_arow)); + __Pyx_INCREF(((PyObject *)__pyx_v_acol)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_acol)); + PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, ((PyObject *)__pyx_v_acol)); + __Pyx_INCREF(((PyObject *)__pyx_v_aval)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_aval)); + PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, ((PyObject *)__pyx_v_aval)); + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":50 + * """ + * + * assert arow.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_arow->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 50; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":51 + * + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz # <<<<<<<<<<<<<< + * assert aval.shape[0] == self.nnz + * + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_acol->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 51; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":52 + * assert arow.shape[0] == self.nnz + * assert acol.shape[0] == self.nnz + * assert aval.shape[0] == self.nnz # <<<<<<<<<<<<<< + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!(((__pyx_v_aval->dimensions[0]) == __pyx_v_self->__pyx_base.nnz) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + {__pyx_filename = __pyx_f[0]; __pyx_lineno = 52; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":54 + * assert aval.shape[0] == self.nnz + * + * self.get_data_pointers( cnp.PyArray_DATA(arow), # <<<<<<<<<<<<<< + * cnp.PyArray_DATA(acol), + * cnp.PyArray_DATA(aval)) + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self->__pyx_base.__pyx_vtab)->__pyx_base.get_data_pointers(((struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_arow))), ((MUMPS_INT *)PyArray_DATA(((PyArrayObject *)__pyx_v_acol))), ((DMUMPS_COMPLEX *)PyArray_DATA(((PyArrayObject *)__pyx_v_aval)))); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 54; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":37 + * pass + * + * cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, # <<<<<<<<<<<<<< + * cnp.ndarray[MUMPS_INT, ndim=1] acol, + * cnp.ndarray[DMUMPS_COMPLEX, ndim=1] aval): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT64.NumpyMUMPSSolver_INT32_FLOAT64.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_2get_matrix_data[] = "\n\n Args:\n arow: row indices of non zero elements of A\n acol: column indices of non zero elements of A\n aval: values of non zeros elements of A\n\n Note: we keep the same name for this method in all derived classes.\n "; +static PyObject *__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_3get_matrix_data(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyArrayObject *__pyx_v_arow = 0; + PyArrayObject *__pyx_v_acol = 0; + PyArrayObject *__pyx_v_aval = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_matrix_data (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_arow,&__pyx_n_s_acol,&__pyx_n_s_aval,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_arow)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + case 1: + if (likely((values[1] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_acol)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 1); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + case 2: + if (likely((values[2] = PyDict_GetItem(__pyx_kwds, __pyx_n_s_aval)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, 2); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_matrix_data") < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v_arow = ((PyArrayObject *)values[0]); + __pyx_v_acol = ((PyArrayObject *)values[1]); + __pyx_v_aval = ((PyArrayObject *)values[2]); + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_matrix_data", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L3_error;} + __pyx_L3_error:; + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT64.NumpyMUMPSSolver_INT32_FLOAT64.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_arow), __pyx_ptype_5numpy_ndarray, 1, "arow", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_acol), __pyx_ptype_5numpy_ndarray, 1, "acol", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 38; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_aval), __pyx_ptype_5numpy_ndarray, 1, "aval", 0))) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 39; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_r = __pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_2get_matrix_data(((struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *)__pyx_v_self), __pyx_v_arow, __pyx_v_acol, __pyx_v_aval); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_2get_matrix_data(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *__pyx_v_self, PyArrayObject *__pyx_v_arow, PyArrayObject *__pyx_v_acol, PyArrayObject *__pyx_v_aval) { + __Pyx_LocalBuf_ND __pyx_pybuffernd_acol; + __Pyx_Buffer __pyx_pybuffer_acol; + __Pyx_LocalBuf_ND __pyx_pybuffernd_arow; + __Pyx_Buffer __pyx_pybuffer_arow; + __Pyx_LocalBuf_ND __pyx_pybuffernd_aval; + __Pyx_Buffer __pyx_pybuffer_aval; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_matrix_data", 0); + __pyx_pybuffer_arow.pybuffer.buf = NULL; + __pyx_pybuffer_arow.refcount = 0; + __pyx_pybuffernd_arow.data = NULL; + __pyx_pybuffernd_arow.rcbuffer = &__pyx_pybuffer_arow; + __pyx_pybuffer_acol.pybuffer.buf = NULL; + __pyx_pybuffer_acol.refcount = 0; + __pyx_pybuffernd_acol.data = NULL; + __pyx_pybuffernd_acol.rcbuffer = &__pyx_pybuffer_acol; + __pyx_pybuffer_aval.pybuffer.buf = NULL; + __pyx_pybuffer_aval.refcount = 0; + __pyx_pybuffernd_aval.data = NULL; + __pyx_pybuffernd_aval.rcbuffer = &__pyx_pybuffer_aval; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_arow.rcbuffer->pybuffer, (PyObject*)__pyx_v_arow, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_arow.diminfo[0].strides = __pyx_pybuffernd_arow.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_arow.diminfo[0].shape = __pyx_pybuffernd_arow.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_acol.rcbuffer->pybuffer, (PyObject*)__pyx_v_acol, &__Pyx_TypeInfo_nn_MUMPS_INT, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_acol.diminfo[0].strides = __pyx_pybuffernd_acol.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_acol.diminfo[0].shape = __pyx_pybuffernd_acol.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_aval.rcbuffer->pybuffer, (PyObject*)__pyx_v_aval, &__Pyx_TypeInfo_nn_DMUMPS_COMPLEX, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_pybuffernd_aval.diminfo[0].strides = __pyx_pybuffernd_aval.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_aval.diminfo[0].shape = __pyx_pybuffernd_aval.rcbuffer->pybuffer.shape[0]; + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_get_matrix_data(__pyx_v_self, ((PyArrayObject *)__pyx_v_arow), ((PyArrayObject *)__pyx_v_acol), ((PyArrayObject *)__pyx_v_aval), 1); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 37; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("mumps.src.numpy_mumps_INT32_FLOAT64.NumpyMUMPSSolver_INT32_FLOAT64.get_matrix_data", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_acol.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_arow.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_aval.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_pw_5numpy_7ndarray_1__getbuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_pf_5numpy_7ndarray___getbuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_5numpy_7ndarray___getbuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_copy_shape; + int __pyx_v_i; + int __pyx_v_ndim; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + int __pyx_v_t; + char *__pyx_v_f; + PyArray_Descr *__pyx_v_descr = 0; + int __pyx_v_offset; + int __pyx_v_hasfields; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getbuffer__", 0); + if (__pyx_v_info != NULL) { + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":203 + * # of flags + * + * if info == NULL: return # <<<<<<<<<<<<<< + * + * cdef int copy_shape, i, ndim + */ + __pyx_t_1 = ((__pyx_v_info == NULL) != 0); + if (__pyx_t_1) { + __pyx_r = 0; + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":206 + * + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":207 + * cdef int copy_shape, i, ndim + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * + * ndim = PyArray_NDIM(self) + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":209 + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * + * ndim = PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_v_ndim = PyArray_NDIM(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":212 + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * copy_shape = 1 # <<<<<<<<<<<<<< + * else: + * copy_shape = 0 + */ + __pyx_v_copy_shape = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":211 + * ndim = PyArray_NDIM(self) + * + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * copy_shape = 1 + * else: + */ + goto __pyx_L4; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":214 + * copy_shape = 1 + * else: + * copy_shape = 0 # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + */ + /*else*/ { + __pyx_v_copy_shape = 0; + } + __pyx_L4:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L6_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":217 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not C contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_C_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L6_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":216 + * copy_shape = 0 + * + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + __pyx_t_2 = (((__pyx_v_flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":221 + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): # <<<<<<<<<<<<<< + * raise ValueError(u"ndarray is not Fortran contiguous") + * + */ + __pyx_t_2 = ((!(PyArray_CHKFLAGS(__pyx_v_self, NPY_F_CONTIGUOUS) != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":220 + * raise ValueError(u"ndarray is not C contiguous") + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) # <<<<<<<<<<<<<< + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":224 + * raise ValueError(u"ndarray is not Fortran contiguous") + * + * info.buf = PyArray_DATA(self) # <<<<<<<<<<<<<< + * info.ndim = ndim + * if copy_shape: + */ + __pyx_v_info->buf = PyArray_DATA(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":225 + * + * info.buf = PyArray_DATA(self) + * info.ndim = ndim # <<<<<<<<<<<<<< + * if copy_shape: + * # Allocate new buffer for strides and shape info. + */ + __pyx_v_info->ndim = __pyx_v_ndim; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + __pyx_t_1 = (__pyx_v_copy_shape != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":229 + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) # <<<<<<<<<<<<<< + * info.shape = info.strides + ndim + * for i in range(ndim): + */ + __pyx_v_info->strides = ((Py_ssize_t *)malloc((((sizeof(Py_ssize_t)) * ((size_t)__pyx_v_ndim)) * 2))); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":230 + * # This is allocated as one block, strides first. + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim # <<<<<<<<<<<<<< + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + */ + __pyx_v_info->shape = (__pyx_v_info->strides + __pyx_v_ndim); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":231 + * info.strides = stdlib.malloc(sizeof(Py_ssize_t) * ndim * 2) + * info.shape = info.strides + ndim + * for i in range(ndim): # <<<<<<<<<<<<<< + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] + */ + __pyx_t_4 = __pyx_v_ndim; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":232 + * info.shape = info.strides + ndim + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] # <<<<<<<<<<<<<< + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + */ + (__pyx_v_info->strides[__pyx_v_i]) = (PyArray_STRIDES(__pyx_v_self)[__pyx_v_i]); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":233 + * for i in range(ndim): + * info.strides[i] = PyArray_STRIDES(self)[i] + * info.shape[i] = PyArray_DIMS(self)[i] # <<<<<<<<<<<<<< + * else: + * info.strides = PyArray_STRIDES(self) + */ + (__pyx_v_info->shape[__pyx_v_i]) = (PyArray_DIMS(__pyx_v_self)[__pyx_v_i]); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":226 + * info.buf = PyArray_DATA(self) + * info.ndim = ndim + * if copy_shape: # <<<<<<<<<<<<<< + * # Allocate new buffer for strides and shape info. + * # This is allocated as one block, strides first. + */ + goto __pyx_L11; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":235 + * info.shape[i] = PyArray_DIMS(self)[i] + * else: + * info.strides = PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + */ + /*else*/ { + __pyx_v_info->strides = ((Py_ssize_t *)PyArray_STRIDES(__pyx_v_self)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":236 + * else: + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + */ + __pyx_v_info->shape = ((Py_ssize_t *)PyArray_DIMS(__pyx_v_self)); + } + __pyx_L11:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":237 + * info.strides = PyArray_STRIDES(self) + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) + */ + __pyx_v_info->suboffsets = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":238 + * info.shape = PyArray_DIMS(self) + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) # <<<<<<<<<<<<<< + * info.readonly = not PyArray_ISWRITEABLE(self) + * + */ + __pyx_v_info->itemsize = PyArray_ITEMSIZE(__pyx_v_self); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":239 + * info.suboffsets = NULL + * info.itemsize = PyArray_ITEMSIZE(self) + * info.readonly = not PyArray_ISWRITEABLE(self) # <<<<<<<<<<<<<< + * + * cdef int t + */ + __pyx_v_info->readonly = (!(PyArray_ISWRITEABLE(__pyx_v_self) != 0)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":242 + * + * cdef int t + * cdef char* f = NULL # <<<<<<<<<<<<<< + * cdef dtype descr = self.descr + * cdef int offset + */ + __pyx_v_f = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":243 + * cdef int t + * cdef char* f = NULL + * cdef dtype descr = self.descr # <<<<<<<<<<<<<< + * cdef int offset + * + */ + __pyx_t_3 = ((PyObject *)__pyx_v_self->descr); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_descr = ((PyArray_Descr *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":246 + * cdef int offset + * + * cdef bint hasfields = PyDataType_HASFIELDS(descr) # <<<<<<<<<<<<<< + * + * if not hasfields and not copy_shape: + */ + __pyx_v_hasfields = PyDataType_HASFIELDS(__pyx_v_descr); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + __pyx_t_2 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L15_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_copy_shape != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L15_bool_binop_done:; + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":250 + * if not hasfields and not copy_shape: + * # do not call releasebuffer + * info.obj = None # <<<<<<<<<<<<<< + * else: + * # need to call releasebuffer + */ + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = Py_None; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":248 + * cdef bint hasfields = PyDataType_HASFIELDS(descr) + * + * if not hasfields and not copy_shape: # <<<<<<<<<<<<<< + * # do not call releasebuffer + * info.obj = None + */ + goto __pyx_L14; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":253 + * else: + * # need to call releasebuffer + * info.obj = self # <<<<<<<<<<<<<< + * + * if not hasfields: + */ + /*else*/ { + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + } + __pyx_L14:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + __pyx_t_1 = ((!(__pyx_v_hasfields != 0)) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":256 + * + * if not hasfields: + * t = descr.type_num # <<<<<<<<<<<<<< + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + */ + __pyx_t_4 = __pyx_v_descr->type_num; + __pyx_v_t = __pyx_t_4; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '>') != 0); + if (!__pyx_t_2) { + goto __pyx_L20_next_or; + } else { + } + __pyx_t_2 = (__pyx_v_little_endian != 0); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_L20_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":258 + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + */ + __pyx_t_2 = ((__pyx_v_descr->byteorder == '<') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_2 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L19_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":257 + * if not hasfields: + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":260 + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + */ + switch (__pyx_v_t) { + case NPY_BYTE: + __pyx_v_f = __pyx_k_b; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":261 + * raise ValueError(u"Non-native byte order not supported") + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + */ + case NPY_UBYTE: + __pyx_v_f = __pyx_k_B; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":262 + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + */ + case NPY_SHORT: + __pyx_v_f = __pyx_k_h; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":263 + * elif t == NPY_UBYTE: f = "B" + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + */ + case NPY_USHORT: + __pyx_v_f = __pyx_k_H; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":264 + * elif t == NPY_SHORT: f = "h" + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + */ + case NPY_INT: + __pyx_v_f = __pyx_k_i; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":265 + * elif t == NPY_USHORT: f = "H" + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + */ + case NPY_UINT: + __pyx_v_f = __pyx_k_I; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":266 + * elif t == NPY_INT: f = "i" + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + */ + case NPY_LONG: + __pyx_v_f = __pyx_k_l; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":267 + * elif t == NPY_UINT: f = "I" + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + */ + case NPY_ULONG: + __pyx_v_f = __pyx_k_L; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":268 + * elif t == NPY_LONG: f = "l" + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + */ + case NPY_LONGLONG: + __pyx_v_f = __pyx_k_q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":269 + * elif t == NPY_ULONG: f = "L" + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + */ + case NPY_ULONGLONG: + __pyx_v_f = __pyx_k_Q; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":270 + * elif t == NPY_LONGLONG: f = "q" + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + */ + case NPY_FLOAT: + __pyx_v_f = __pyx_k_f; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":271 + * elif t == NPY_ULONGLONG: f = "Q" + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + */ + case NPY_DOUBLE: + __pyx_v_f = __pyx_k_d; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":272 + * elif t == NPY_FLOAT: f = "f" + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + */ + case NPY_LONGDOUBLE: + __pyx_v_f = __pyx_k_g; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":273 + * elif t == NPY_DOUBLE: f = "d" + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + */ + case NPY_CFLOAT: + __pyx_v_f = __pyx_k_Zf; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":274 + * elif t == NPY_LONGDOUBLE: f = "g" + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" + */ + case NPY_CDOUBLE: + __pyx_v_f = __pyx_k_Zd; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":275 + * elif t == NPY_CFLOAT: f = "Zf" + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f = "O" + * else: + */ + case NPY_CLONGDOUBLE: + __pyx_v_f = __pyx_k_Zg; + break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":276 + * elif t == NPY_CDOUBLE: f = "Zd" + * elif t == NPY_CLONGDOUBLE: f = "Zg" + * elif t == NPY_OBJECT: f = "O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + case NPY_OBJECT: + __pyx_v_f = __pyx_k_O; + break; + default: + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":278 + * elif t == NPY_OBJECT: f = "O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * info.format = f + * return + */ + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_t_3); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 278; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + break; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":279 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f # <<<<<<<<<<<<<< + * return + * else: + */ + __pyx_v_info->format = __pyx_v_f; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":280 + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * info.format = f + * return # <<<<<<<<<<<<<< + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":255 + * info.obj = self + * + * if not hasfields: # <<<<<<<<<<<<<< + * t = descr.type_num + * if ((descr.byteorder == c'>' and little_endian) or + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":282 + * return + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) # <<<<<<<<<<<<<< + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + */ + /*else*/ { + __pyx_v_info->format = ((char *)malloc(0xFF)); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":283 + * else: + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment # <<<<<<<<<<<<<< + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, + */ + (__pyx_v_info->format[0]) = '^'; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":284 + * info.format = stdlib.malloc(_buffer_format_string_len) + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 # <<<<<<<<<<<<<< + * f = _util_dtypestring(descr, info.format + 1, + * info.format + _buffer_format_string_len, + */ + __pyx_v_offset = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":285 + * info.format[0] = c'^' # Native data types, manual alignment + * offset = 0 + * f = _util_dtypestring(descr, info.format + 1, # <<<<<<<<<<<<<< + * info.format + _buffer_format_string_len, + * &offset) + */ + __pyx_t_7 = __pyx_f_5numpy__util_dtypestring(__pyx_v_descr, (__pyx_v_info->format + 1), (__pyx_v_info->format + 0xFF), (&__pyx_v_offset)); if (unlikely(__pyx_t_7 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 285; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_7; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":288 + * info.format + _buffer_format_string_len, + * &offset) + * f[0] = c'\0' # Terminate format string # <<<<<<<<<<<<<< + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + */ + (__pyx_v_f[0]) = '\x00'; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":197 + * # experimental exception made for __getbuffer__ and __releasebuffer__ + * # -- the details of this may change. + * def __getbuffer__(ndarray self, Py_buffer* info, int flags): # <<<<<<<<<<<<<< + * # This implementation of getbuffer is geared towards Cython + * # requirements, and does not yet fullfill the PEP. + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("numpy.ndarray.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info != NULL && __pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = NULL; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info != NULL && __pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(Py_None); + __Pyx_DECREF(Py_None); __pyx_v_info->obj = NULL; + } + __pyx_L2:; + __Pyx_XDECREF((PyObject *)__pyx_v_descr); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + +/* Python wrapper */ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info); /*proto*/ +static CYTHON_UNUSED void __pyx_pw_5numpy_7ndarray_3__releasebuffer__(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__releasebuffer__ (wrapper)", 0); + __pyx_pf_5numpy_7ndarray_2__releasebuffer__(((PyArrayObject *)__pyx_v_self), ((Py_buffer *)__pyx_v_info)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_pf_5numpy_7ndarray_2__releasebuffer__(PyArrayObject *__pyx_v_self, Py_buffer *__pyx_v_info) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__releasebuffer__", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + __pyx_t_1 = (PyArray_HASFIELDS(__pyx_v_self) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":292 + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) # <<<<<<<<<<<<<< + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) + */ + free(__pyx_v_info->format); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":291 + * + * def __releasebuffer__(ndarray self, Py_buffer* info): + * if PyArray_HASFIELDS(self): # <<<<<<<<<<<<<< + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + __pyx_t_1 = (((sizeof(npy_intp)) != (sizeof(Py_ssize_t))) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":294 + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): + * stdlib.free(info.strides) # <<<<<<<<<<<<<< + * # info.shape was stored after info.strides in the same block + * + */ + free(__pyx_v_info->strides); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":293 + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + * if sizeof(npy_intp) != sizeof(Py_ssize_t): # <<<<<<<<<<<<<< + * stdlib.free(info.strides) + * # info.shape was stored after info.strides in the same block + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":290 + * f[0] = c'\0' # Terminate format string + * + * def __releasebuffer__(ndarray self, Py_buffer* info): # <<<<<<<<<<<<<< + * if PyArray_HASFIELDS(self): + * stdlib.free(info.format) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":771 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 771; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":770 + * ctypedef npy_cdouble complex_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":774 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 774; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":773 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":777 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 777; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":776 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":780 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 780; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":779 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":783 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 783; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":782 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + +static CYTHON_INLINE char *__pyx_f_5numpy__util_dtypestring(PyArray_Descr *__pyx_v_descr, char *__pyx_v_f, char *__pyx_v_end, int *__pyx_v_offset) { + PyArray_Descr *__pyx_v_child = 0; + int __pyx_v_endian_detector; + int __pyx_v_little_endian; + PyObject *__pyx_v_fields = 0; + PyObject *__pyx_v_childname = NULL; + PyObject *__pyx_v_new_offset = NULL; + PyObject *__pyx_v_t = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + long __pyx_t_8; + char *__pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_util_dtypestring", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":790 + * + * cdef dtype child + * cdef int endian_detector = 1 # <<<<<<<<<<<<<< + * cdef bint little_endian = ((&endian_detector)[0] != 0) + * cdef tuple fields + */ + __pyx_v_endian_detector = 1; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":791 + * cdef dtype child + * cdef int endian_detector = 1 + * cdef bint little_endian = ((&endian_detector)[0] != 0) # <<<<<<<<<<<<<< + * cdef tuple fields + * + */ + __pyx_v_little_endian = ((((char *)(&__pyx_v_endian_detector))[0]) != 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + if (unlikely(__pyx_v_descr->names == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_1 = __pyx_v_descr->names; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; + for (;;) { + if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #else + __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 794; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_XDECREF_SET(__pyx_v_childname, __pyx_t_3); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":795 + * + * for childname in descr.names: + * fields = descr.fields[childname] # <<<<<<<<<<<<<< + * child, new_offset = fields + * + */ + if (unlikely(__pyx_v_descr->fields == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_t_3 = __Pyx_PyDict_GetItem(__pyx_v_descr->fields, __pyx_v_childname); if (unlikely(__pyx_t_3 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(PyTuple_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_t_3)->tp_name), 0))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 795; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_fields, ((PyObject*)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":796 + * for childname in descr.names: + * fields = descr.fields[childname] + * child, new_offset = fields # <<<<<<<<<<<<<< + * + * if (end - f) - (new_offset - offset[0]) < 15: + */ + if (likely(__pyx_v_fields != Py_None)) { + PyObject* sequence = __pyx_v_fields; + #if CYTHON_COMPILING_IN_CPYTHON + Py_ssize_t size = Py_SIZE(sequence); + #else + Py_ssize_t size = PySequence_Size(sequence); + #endif + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if CYTHON_COMPILING_IN_CPYTHON + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + #endif + } else { + __Pyx_RaiseNoneNotIterableError(); {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_ptype_5numpy_dtype))))) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 796; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_XDECREF_SET(__pyx_v_child, ((PyArray_Descr *)__pyx_t_3)); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_new_offset, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + __pyx_t_4 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Subtract(__pyx_v_new_offset, __pyx_t_4); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 798; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = ((((__pyx_v_end - __pyx_v_f) - ((int)__pyx_t_5)) < 15) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":798 + * child, new_offset = fields + * + * if (end - f) - (new_offset - offset[0]) < 15: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '>') != 0); + if (!__pyx_t_7) { + goto __pyx_L8_next_or; + } else { + } + __pyx_t_7 = (__pyx_v_little_endian != 0); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_L8_next_or:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":802 + * + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): # <<<<<<<<<<<<<< + * raise ValueError(u"Non-native byte order not supported") + * # One could encode it in the format string and have Cython + */ + __pyx_t_7 = ((__pyx_v_child->byteorder == '<') != 0); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_7 = ((!(__pyx_v_little_endian != 0)) != 0); + __pyx_t_6 = __pyx_t_7; + __pyx_L7_bool_binop_done:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":801 + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") + * + * if ((child.byteorder == c'>' and little_endian) or # <<<<<<<<<<<<<< + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":813 + * + * # Output padding bytes + * while offset[0] < new_offset: # <<<<<<<<<<<<<< + * f[0] = 120 # "x"; pad byte + * f += 1 + */ + while (1) { + __pyx_t_3 = __Pyx_PyInt_From_int((__pyx_v_offset[0])); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_new_offset, Py_LT); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 813; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!__pyx_t_6) break; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":814 + * # Output padding bytes + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte # <<<<<<<<<<<<<< + * f += 1 + * offset[0] += 1 + */ + (__pyx_v_f[0]) = 0x78; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":815 + * while offset[0] < new_offset: + * f[0] = 120 # "x"; pad byte + * f += 1 # <<<<<<<<<<<<<< + * offset[0] += 1 + * + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":816 + * f[0] = 120 # "x"; pad byte + * f += 1 + * offset[0] += 1 # <<<<<<<<<<<<<< + * + * offset[0] += child.itemsize + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + 1); + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":818 + * offset[0] += 1 + * + * offset[0] += child.itemsize # <<<<<<<<<<<<<< + * + * if not PyDataType_HASFIELDS(child): + */ + __pyx_t_8 = 0; + (__pyx_v_offset[__pyx_t_8]) = ((__pyx_v_offset[__pyx_t_8]) + __pyx_v_child->elsize); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + __pyx_t_6 = ((!(PyDataType_HASFIELDS(__pyx_v_child) != 0)) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":821 + * + * if not PyDataType_HASFIELDS(child): + * t = child.type_num # <<<<<<<<<<<<<< + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") + */ + __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_v_child->type_num); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 821; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_t, __pyx_t_4); + __pyx_t_4 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + __pyx_t_6 = (((__pyx_v_end - __pyx_v_f) < 5) != 0); + if (__pyx_t_6) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":822 + * if not PyDataType_HASFIELDS(child): + * t = child.type_num + * if end - f < 5: # <<<<<<<<<<<<<< + * raise RuntimeError(u"Format string allocated too short.") + * + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":826 + * + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" # <<<<<<<<<<<<<< + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_BYTE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 826; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 98; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":827 + * # Until ticket #99 is fixed, use integers to avoid warnings + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" # <<<<<<<<<<<<<< + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UBYTE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 827; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":828 + * if t == NPY_BYTE: f[0] = 98 #"b" + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" # <<<<<<<<<<<<<< + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_SHORT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 828; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x68; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":829 + * elif t == NPY_UBYTE: f[0] = 66 #"B" + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" # <<<<<<<<<<<<<< + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_USHORT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 829; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 72; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":830 + * elif t == NPY_SHORT: f[0] = 104 #"h" + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" # <<<<<<<<<<<<<< + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_INT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 830; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x69; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":831 + * elif t == NPY_USHORT: f[0] = 72 #"H" + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" # <<<<<<<<<<<<<< + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_UINT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 831; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 73; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":832 + * elif t == NPY_INT: f[0] = 105 #"i" + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" # <<<<<<<<<<<<<< + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 832; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x6C; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":833 + * elif t == NPY_UINT: f[0] = 73 #"I" + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" # <<<<<<<<<<<<<< + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 833; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 76; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":834 + * elif t == NPY_LONG: f[0] = 108 #"l" + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" # <<<<<<<<<<<<<< + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGLONG); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 834; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x71; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":835 + * elif t == NPY_ULONG: f[0] = 76 #"L" + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" # <<<<<<<<<<<<<< + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_ULONGLONG); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 835; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 81; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":836 + * elif t == NPY_LONGLONG: f[0] = 113 #"q" + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" # <<<<<<<<<<<<<< + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_FLOAT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 836; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x66; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":837 + * elif t == NPY_ULONGLONG: f[0] = 81 #"Q" + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" # <<<<<<<<<<<<<< + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_DOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 837; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x64; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":838 + * elif t == NPY_FLOAT: f[0] = 102 #"f" + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" # <<<<<<<<<<<<<< + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_LONGDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 838; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 0x67; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":839 + * elif t == NPY_DOUBLE: f[0] = 100 #"d" + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf # <<<<<<<<<<<<<< + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CFLOAT); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 839; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x66; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":840 + * elif t == NPY_LONGDOUBLE: f[0] = 103 #"g" + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd # <<<<<<<<<<<<<< + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CDOUBLE); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 840; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x64; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":841 + * elif t == NPY_CFLOAT: f[0] = 90; f[1] = 102; f += 1 # Zf + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg # <<<<<<<<<<<<<< + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + */ + __pyx_t_3 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_CLONGDOUBLE); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyObject_RichCompare(__pyx_v_t, __pyx_t_3, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 841; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 90; + (__pyx_v_f[1]) = 0x67; + __pyx_v_f = (__pyx_v_f + 1); + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":842 + * elif t == NPY_CDOUBLE: f[0] = 90; f[1] = 100; f += 1 # Zd + * elif t == NPY_CLONGDOUBLE: f[0] = 90; f[1] = 103; f += 1 # Zg + * elif t == NPY_OBJECT: f[0] = 79 #"O" # <<<<<<<<<<<<<< + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + */ + __pyx_t_4 = __Pyx_PyInt_From_enum__NPY_TYPES(NPY_OBJECT); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_t, __pyx_t_4, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_6 < 0)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 842; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_6) { + (__pyx_v_f[0]) = 79; + goto __pyx_L15; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":844 + * elif t == NPY_OBJECT: f[0] = 79 #"O" + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) # <<<<<<<<<<<<<< + * f += 1 + * else: + */ + /*else*/ { + __pyx_t_3 = PyUnicode_Format(__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_v_t); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + {__pyx_filename = __pyx_f[1]; __pyx_lineno = 844; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + __pyx_L15:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":845 + * else: + * raise ValueError(u"unknown dtype code in numpy.pxd (%d)" % t) + * f += 1 # <<<<<<<<<<<<<< + * else: + * # Cython ignores struct boundary information ("T{...}"), + */ + __pyx_v_f = (__pyx_v_f + 1); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":820 + * offset[0] += child.itemsize + * + * if not PyDataType_HASFIELDS(child): # <<<<<<<<<<<<<< + * t = child.type_num + * if end - f < 5: + */ + goto __pyx_L13; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":849 + * # Cython ignores struct boundary information ("T{...}"), + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) # <<<<<<<<<<<<<< + * return f + * + */ + /*else*/ { + __pyx_t_9 = __pyx_f_5numpy__util_dtypestring(__pyx_v_child, __pyx_v_f, __pyx_v_end, __pyx_v_offset); if (unlikely(__pyx_t_9 == NULL)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 849; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_v_f = __pyx_t_9; + } + __pyx_L13:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":794 + * cdef tuple fields + * + * for childname in descr.names: # <<<<<<<<<<<<<< + * fields = descr.fields[childname] + * child, new_offset = fields + */ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":850 + * # so don't output it + * f = _util_dtypestring(child, f, end, offset) + * return f # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_f; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":785 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline char* _util_dtypestring(dtype descr, char* f, char* end, int* offset) except NULL: # <<<<<<<<<<<<<< + * # Recursive utility function used in __getbuffer__ to get format + * # string. The new location in the format string is returned. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("numpy._util_dtypestring", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_child); + __Pyx_XDECREF(__pyx_v_fields); + __Pyx_XDECREF(__pyx_v_childname); + __Pyx_XDECREF(__pyx_v_new_offset); + __Pyx_XDECREF(__pyx_v_t); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + PyObject *__pyx_v_baseptr; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + __Pyx_RefNannySetupContext("set_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + __pyx_t_1 = (__pyx_v_base == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":969 + * cdef PyObject* baseptr + * if base is None: + * baseptr = NULL # <<<<<<<<<<<<<< + * else: + * Py_INCREF(base) # important to do this before decref below! + */ + __pyx_v_baseptr = NULL; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":968 + * cdef inline void set_array_base(ndarray arr, object base): + * cdef PyObject* baseptr + * if base is None: # <<<<<<<<<<<<<< + * baseptr = NULL + * else: + */ + goto __pyx_L3; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":971 + * baseptr = NULL + * else: + * Py_INCREF(base) # important to do this before decref below! # <<<<<<<<<<<<<< + * baseptr = base + * Py_XDECREF(arr.base) + */ + /*else*/ { + Py_INCREF(__pyx_v_base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":972 + * else: + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base # <<<<<<<<<<<<<< + * Py_XDECREF(arr.base) + * arr.base = baseptr + */ + __pyx_v_baseptr = ((PyObject *)__pyx_v_base); + } + __pyx_L3:; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":973 + * Py_INCREF(base) # important to do this before decref below! + * baseptr = base + * Py_XDECREF(arr.base) # <<<<<<<<<<<<<< + * arr.base = baseptr + * + */ + Py_XDECREF(__pyx_v_arr->base); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":974 + * baseptr = base + * Py_XDECREF(arr.base) + * arr.base = baseptr # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): + */ + __pyx_v_arr->base = __pyx_v_baseptr; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":966 + * + * + * cdef inline void set_array_base(ndarray arr, object base): # <<<<<<<<<<<<<< + * cdef PyObject* baseptr + * if base is None: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + __pyx_t_1 = ((__pyx_v_arr->base == NULL) != 0); + if (__pyx_t_1) { + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":978 + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: + * return None # <<<<<<<<<<<<<< + * else: + * return arr.base + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_None); + __pyx_r = Py_None; + goto __pyx_L0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":977 + * + * cdef inline object get_array_base(ndarray arr): + * if arr.base is NULL: # <<<<<<<<<<<<<< + * return None + * else: + */ + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":980 + * return None + * else: + * return arr.base # <<<<<<<<<<<<<< + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_arr->base)); + __pyx_r = ((PyObject *)__pyx_v_arr->base); + goto __pyx_L0; + } + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 __pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64; + +static PyObject *__pyx_tp_new_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *p; + PyObject *o = __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64->tp_new(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64*)__pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64; + if (unlikely(__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_1__cinit__(o, a, k) < 0)) { + Py_DECREF(o); o = 0; + } + return o; +} + +static void __pyx_tp_dealloc_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64(PyObject *o) { + #if PY_VERSION_HEX >= 0x030400a1 + if (unlikely(Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + PyObject_GC_Track(o); + if (likely(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64)) __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64->tp_dealloc(o); else __Pyx_call_next_tp_dealloc(o, __pyx_tp_dealloc_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64); +} + +static int __pyx_tp_traverse_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64(PyObject *o, visitproc v, void *a) { + int e; + e = ((likely(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64)) ? ((__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64->tp_traverse) ? __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64->tp_traverse(o, v, a) : 0) : __Pyx_call_next_tp_traverse(o, v, a, __pyx_tp_traverse_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64)); if (e) return e; + return 0; +} + +static int __pyx_tp_clear_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64(PyObject *o) { + if (likely(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64)) { if (__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64->tp_clear) __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64->tp_clear(o); } else __Pyx_call_next_tp_clear(o, __pyx_tp_clear_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64); + return 0; +} + +static PyMethodDef __pyx_methods_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64[] = { + {"get_matrix_data", (PyCFunction)__pyx_pw_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_3get_matrix_data, METH_VARARGS|METH_KEYWORDS, __pyx_doc_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_2get_matrix_data}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 = { + PyVarObject_HEAD_INIT(0, 0) + "mumps.src.numpy_mumps_INT32_FLOAT64.NumpyMUMPSSolver_INT32_FLOAT64", /*tp_name*/ + sizeof(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "\n MUMPS Context.\n\n Only deals with Numpy arrays.\n\n We follow the common use of MUMPS. In particular, we use the same names for the methods of this\n class as their corresponding counter-parts in MUMPS.\n\n Warning: if the numpy arrays are modified externally by the user between 2 calls to solve,\n the changes in arrays won't be passed to MUMPS.\n ", /*tp_doc*/ + __pyx_tp_traverse_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64, /*tp_traverse*/ + __pyx_tp_clear_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; + +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef __pyx_moduledef = { + #if PY_VERSION_HEX < 0x03020000 + { PyObject_HEAD_INIT(NULL) NULL, 0, NULL }, + #else + PyModuleDef_HEAD_INIT, + #endif + "numpy_mumps_INT32_FLOAT64", + 0, /* m_doc */ + -1, /* m_size */ + __pyx_methods /* m_methods */, + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_Format_string_allocated_too_shor, __pyx_k_Format_string_allocated_too_shor, sizeof(__pyx_k_Format_string_allocated_too_shor), 0, 1, 0, 0}, + {&__pyx_kp_u_Format_string_allocated_too_shor_2, __pyx_k_Format_string_allocated_too_shor_2, sizeof(__pyx_k_Format_string_allocated_too_shor_2), 0, 1, 0, 0}, + {&__pyx_kp_u_Non_native_byte_order_not_suppor, __pyx_k_Non_native_byte_order_not_suppor, sizeof(__pyx_k_Non_native_byte_order_not_suppor), 0, 1, 0, 0}, + {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_acol, __pyx_k_acol, sizeof(__pyx_k_acol), 0, 0, 1, 1}, + {&__pyx_n_s_arow, __pyx_k_arow, sizeof(__pyx_k_arow), 0, 0, 1, 1}, + {&__pyx_n_s_aval, __pyx_k_aval, sizeof(__pyx_k_aval), 0, 0, 1, 1}, + {&__pyx_n_s_comm_fortran, __pyx_k_comm_fortran, sizeof(__pyx_k_comm_fortran), 0, 0, 1, 1}, + {&__pyx_n_s_get_matrix_data, __pyx_k_get_matrix_data, sizeof(__pyx_k_get_matrix_data), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_kp_u_ndarray_is_not_C_contiguous, __pyx_k_ndarray_is_not_C_contiguous, sizeof(__pyx_k_ndarray_is_not_C_contiguous), 0, 1, 0, 0}, + {&__pyx_kp_u_ndarray_is_not_Fortran_contiguou, __pyx_k_ndarray_is_not_Fortran_contiguou, sizeof(__pyx_k_ndarray_is_not_Fortran_contiguou), 0, 1, 0, 0}, + {&__pyx_n_s_nnz, __pyx_k_nnz, sizeof(__pyx_k_nnz), 0, 0, 1, 1}, + {&__pyx_n_s_np, __pyx_k_np, sizeof(__pyx_k_np), 0, 0, 1, 1}, + {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1}, + {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, + {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, + {&__pyx_n_s_sym, __pyx_k_sym, sizeof(__pyx_k_sym), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_kp_u_unknown_dtype_code_in_numpy_pxd, __pyx_k_unknown_dtype_code_in_numpy_pxd, sizeof(__pyx_k_unknown_dtype_code_in_numpy_pxd), 0, 1, 0, 0}, + {&__pyx_n_s_verbose, __pyx_k_verbose, sizeof(__pyx_k_verbose), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} +}; +static int __Pyx_InitCachedBuiltins(void) { + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 231; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +static int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":218 + * if ((flags & pybuf.PyBUF_C_CONTIGUOUS == pybuf.PyBUF_C_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_C_CONTIGUOUS)): + * raise ValueError(u"ndarray is not C contiguous") # <<<<<<<<<<<<<< + * + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_C_contiguous); if (unlikely(!__pyx_tuple_)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 218; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":222 + * if ((flags & pybuf.PyBUF_F_CONTIGUOUS == pybuf.PyBUF_F_CONTIGUOUS) + * and not PyArray_CHKFLAGS(self, NPY_F_CONTIGUOUS)): + * raise ValueError(u"ndarray is not Fortran contiguous") # <<<<<<<<<<<<<< + * + * info.buf = PyArray_DATA(self) + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_u_ndarray_is_not_Fortran_contiguou); if (unlikely(!__pyx_tuple__2)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 222; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":259 + * if ((descr.byteorder == c'>' and little_endian) or + * (descr.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * if t == NPY_BYTE: f = "b" + * elif t == NPY_UBYTE: f = "B" + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__3)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 259; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":799 + * + * if (end - f) - (new_offset - offset[0]) < 15: + * raise RuntimeError(u"Format string allocated too short, see comment in numpy.pxd") # <<<<<<<<<<<<<< + * + * if ((child.byteorder == c'>' and little_endian) or + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor); if (unlikely(!__pyx_tuple__4)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 799; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":803 + * if ((child.byteorder == c'>' and little_endian) or + * (child.byteorder == c'<' and not little_endian)): + * raise ValueError(u"Non-native byte order not supported") # <<<<<<<<<<<<<< + * # One could encode it in the format string and have Cython + * # complain instead, BUT: < and > in format strings also imply + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_u_Non_native_byte_order_not_suppor); if (unlikely(!__pyx_tuple__5)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 803; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":823 + * t = child.type_num + * if end - f < 5: + * raise RuntimeError(u"Format string allocated too short.") # <<<<<<<<<<<<<< + * + * # Until ticket #99 is fixed, use integers to avoid warnings + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_u_Format_string_allocated_too_shor_2); if (unlikely(!__pyx_tuple__6)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 823; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_InitGlobals(void) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + __pyx_int_neg_987654 = PyInt_FromLong(-987654L); if (unlikely(!__pyx_int_neg_987654)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + return 0; + __pyx_L1_error:; + return -1; +} + +#if PY_MAJOR_VERSION < 3 +PyMODINIT_FUNC initnumpy_mumps_INT32_FLOAT64(void); /*proto*/ +PyMODINIT_FUNC initnumpy_mumps_INT32_FLOAT64(void) +#else +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_FLOAT64(void); /*proto*/ +PyMODINIT_FUNC PyInit_numpy_mumps_INT32_FLOAT64(void) +#endif +{ + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + __Pyx_RefNannySetupContext("PyMODINIT_FUNC PyInit_numpy_mumps_INT32_FLOAT64(void)", 0); + if (__Pyx_check_binary_version() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + #ifdef WITH_THREAD /* Python build with threading support? */ + PyEval_InitThreads(); + #endif + #endif + /*--- Module creation code ---*/ + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("numpy_mumps_INT32_FLOAT64", __pyx_methods, 0, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + #endif + if (unlikely(!__pyx_m)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_INCREF(__pyx_d); + __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if CYTHON_COMPILING_IN_PYPY + Py_INCREF(__pyx_b); + #endif + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;}; + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitGlobals() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if (__Pyx_init_sys_getdefaultencoding_params() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + if (__pyx_module_is_main_mumps__src__numpy_mumps_INT32_FLOAT64) { + if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (!PyDict_GetItemString(modules, "mumps.src.numpy_mumps_INT32_FLOAT64")) { + if (unlikely(PyDict_SetItemString(modules, "mumps.src.numpy_mumps_INT32_FLOAT64", __pyx_m) < 0)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Global init code ---*/ + /*--- Variable export code ---*/ + /*--- Function export code ---*/ + /*--- Type init code ---*/ + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 = __Pyx_ImportType("mumps.src.mumps_INT32_FLOAT64", "BaseMUMPSSolver_INT32_FLOAT64", sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64), 1); if (unlikely(!__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64 = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 = &__pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64; + __pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64.__pyx_base = *__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + __pyx_vtable_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64.get_matrix_data = (PyObject *(*)(struct __pyx_obj_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 *, PyArrayObject *, PyArrayObject *, PyArrayObject *, int __pyx_skip_dispatch))__pyx_f_5mumps_3src_25numpy_mumps_INT32_FLOAT64_30NumpyMUMPSSolver_INT32_FLOAT64_get_matrix_data; + __pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64.tp_base = __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_BaseMUMPSSolver_INT32_FLOAT64; + if (PyType_Ready(&__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64.tp_print = 0; + if (__Pyx_SetVtable(__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64.tp_dict, __pyx_vtabptr_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (PyObject_SetAttrString(__pyx_m, "NumpyMUMPSSolver_INT32_FLOAT64", (PyObject *)&__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 10; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64 = &__pyx_type_5mumps_3src_25numpy_mumps_INT32_FLOAT64_NumpyMUMPSSolver_INT32_FLOAT64; + /*--- Type import code ---*/ + __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__Pyx_BUILTIN_MODULE_NAME, "type", + #if CYTHON_COMPILING_IN_PYPY + sizeof(PyTypeObject), + #else + sizeof(PyHeapTypeObject), + #endif + 0); if (unlikely(!__pyx_ptype_7cpython_4type_type)) {__pyx_filename = __pyx_f[2]; __pyx_lineno = 9; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_dtype = __Pyx_ImportType("numpy", "dtype", sizeof(PyArray_Descr), 0); if (unlikely(!__pyx_ptype_5numpy_dtype)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 155; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_flatiter = __Pyx_ImportType("numpy", "flatiter", sizeof(PyArrayIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_flatiter)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 168; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_broadcast = __Pyx_ImportType("numpy", "broadcast", sizeof(PyArrayMultiIterObject), 0); if (unlikely(!__pyx_ptype_5numpy_broadcast)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 172; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ndarray = __Pyx_ImportType("numpy", "ndarray", sizeof(PyArrayObject), 0); if (unlikely(!__pyx_ptype_5numpy_ndarray)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 181; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5numpy_ufunc = __Pyx_ImportType("numpy", "ufunc", sizeof(PyUFuncObject), 0); if (unlikely(!__pyx_ptype_5numpy_ufunc)) {__pyx_filename = __pyx_f[1]; __pyx_lineno = 861; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array = __Pyx_ImportType("mumps.src.mumps_INT32_FLOAT64", "mumps_int_array", sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_mumps_int_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 113; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array = __Pyx_ImportType("mumps.src.mumps_INT32_FLOAT64", "dmumps_real_array", sizeof(struct __pyx_obj_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array), 1); if (unlikely(!__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array = (struct __pyx_vtabstruct_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array*)__Pyx_GetVtable(__pyx_ptype_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array->tp_dict); if (unlikely(!__pyx_vtabptr_5mumps_3src_19mumps_INT32_FLOAT64_dmumps_real_array)) {__pyx_filename = __pyx_f[3]; __pyx_lineno = 125; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + /*--- Variable import code ---*/ + /*--- Function import code ---*/ + __pyx_t_1 = __Pyx_ImportModule("mumps.src.mumps_INT32_FLOAT64"); if (!__pyx_t_1) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + if (__Pyx_ImportFunction(__pyx_t_1, "c_to_fortran_index_array", (void (**)(void))&__pyx_f_5mumps_3src_19mumps_INT32_FLOAT64_c_to_fortran_index_array, "PyObject *(MUMPS_INT *, MUMPS_INT)") < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + Py_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*--- Execution code ---*/ + #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) + if (__Pyx_patch_abc() < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + #endif + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":4 + * from mumps.src.mumps_INT32_FLOAT64 cimport DMUMPS_COMPLEX + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * + */ + __pyx_t_2 = __Pyx_Import(__pyx_n_s_numpy, 0, -1); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_np, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 4; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":7 + * cimport numpy as cnp + * + * cnp.import_array() # <<<<<<<<<<<<<< + * + * + */ + import_array(); + + /* "mumps/src/numpy_mumps_INT32_FLOAT64.pyx":1 + * from mumps.src.mumps_INT32_FLOAT64 cimport BaseMUMPSSolver_INT32_FLOAT64, c_to_fortran_index_array, MUMPS_INT # <<<<<<<<<<<<<< + * from mumps.src.mumps_INT32_FLOAT64 cimport DMUMPS_COMPLEX + * + */ + __pyx_t_2 = PyDict_New(); if (unlikely(!__pyx_t_2)) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) {__pyx_filename = __pyx_f[0]; __pyx_lineno = 1; __pyx_clineno = __LINE__; goto __pyx_L1_error;} + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "../../lib/python2.7/site-packages/Cython/Includes/numpy/__init__.pxd":976 + * arr.base = baseptr + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * if arr.base is NULL: + * return None + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init mumps.src.numpy_mumps_INT32_FLOAT64", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_DECREF(__pyx_m); __pyx_m = 0; + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init mumps.src.numpy_mumps_INT32_FLOAT64"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if PY_MAJOR_VERSION < 3 + return; + #else + return __pyx_m; + #endif +} + +/* --- Runtime support code --- */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule((char *)modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, (char *)"RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +static CYTHON_INLINE int __Pyx_IsLittleEndian(void) { + unsigned int n = 1; + return *(unsigned char*)(&n) != 0; +} +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t < '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static CYTHON_INLINE PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number; + int ndim = ctx->head->field->type->ndim; +; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_IsLittleEndian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if (ctx->enc_type == *ts && got_Z == ctx->is_complex && + ctx->enc_packmode == ctx->new_packmode) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} +static CYTHON_INLINE void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; +} +static CYTHON_INLINE int __Pyx_GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) +{ + if (obj == Py_None || obj == NULL) { + __Pyx_ZeroBuffer(buf); + return 0; + } + buf->buf = NULL; + if (__Pyx_GetBuffer(obj, buf, flags) == -1) goto fail; + if (buf->ndim != nd) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if ((unsigned)buf->itemsize != dtype->size) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; +fail:; + __Pyx_ZeroBuffer(buf); + return -1; +} +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (info->buf == NULL) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + __Pyx_ReleaseBuffer(info); +} + +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = func->ob_type->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +static CYTHON_INLINE void __Pyx_ErrRestore(PyObject *type, PyObject *value, PyObject *tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyThreadState *tstate = PyThreadState_GET(); + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_Restore(type, value, tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetch(PyObject **type, PyObject **value, PyObject **tb) { +#if CYTHON_COMPILING_IN_CPYTHON + PyThreadState *tstate = PyThreadState_GET(); + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(type, value, tb); +#endif +} + +static void __Pyx_RaiseArgumentTypeInvalid(const char* name, PyObject *obj, PyTypeObject *type) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); +} +static CYTHON_INLINE int __Pyx_ArgTypeTest(PyObject *obj, PyTypeObject *type, int none_allowed, + const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (none_allowed && obj == Py_None) return 1; + else if (exact) { + if (likely(Py_TYPE(obj) == type)) return 1; + #if PY_MAJOR_VERSION == 2 + else if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(PyObject_TypeCheck(obj, type))) return 1; + } + __Pyx_RaiseArgumentTypeInvalid(name, obj, type); + return 0; +} + +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } +#if PY_VERSION_HEX >= 0x03030000 + if (cause) { +#else + if (cause && cause != Py_None) { +#endif + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_COMPILING_IN_PYPY + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#else + PyThreadState *tstate = PyThreadState_GET(); + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(PyObject_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +static void __Pyx_call_next_tp_dealloc(PyObject* obj, destructor current_tp_dealloc) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_dealloc != current_tp_dealloc) + type = type->tp_base; + while (type && type->tp_dealloc == current_tp_dealloc) + type = type->tp_base; + if (type) + type->tp_dealloc(obj); +} + +static int __Pyx_call_next_tp_traverse(PyObject* obj, visitproc v, void *a, traverseproc current_tp_traverse) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_traverse != current_tp_traverse) + type = type->tp_base; + while (type && type->tp_traverse == current_tp_traverse) + type = type->tp_base; + if (type && type->tp_traverse) + return type->tp_traverse(obj, v, a); + return 0; +} + +static void __Pyx_call_next_tp_clear(PyObject* obj, inquiry current_tp_clear) { + PyTypeObject* type = Py_TYPE(obj); + while (type && type->tp_clear != current_tp_clear) + type = type->tp_base; + while (type && type->tp_clear == current_tp_clear) + type = type->tp_base; + if (type && type->tp_clear) + type->tp_clear(obj); +} + +static void* __Pyx_GetVtable(PyObject *dict) { + void* ptr; + PyObject *ob = PyObject_GetItem(dict, __pyx_n_s_pyx_vtable); + if (!ob) + goto bad; +#if PY_VERSION_HEX >= 0x02070000 + ptr = PyCapsule_GetPointer(ob, 0); +#else + ptr = PyCObject_AsVoidPtr(ob); +#endif + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.')) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(1); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + #endif + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_VERSION_HEX < 0x03030000 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_VERSION_HEX < 0x03030000 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, (size_t)new_max*sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyObject *py_srcfile = 0; + PyObject *py_funcname = 0; + #if PY_MAJOR_VERSION < 3 + py_srcfile = PyString_FromString(filename); + #else + py_srcfile = PyUnicode_FromString(filename); + #endif + if (!py_srcfile) goto bad; + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + #else + py_funcname = PyUnicode_FromString(funcname); + #endif + } + if (!py_funcname) goto bad; + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + Py_DECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_srcfile); + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + py_code = __pyx_find_code_object(c_line ? c_line : py_line); + if (!py_code) { + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) goto bad; + __pyx_insert_code_object(c_line ? c_line : py_line, py_code); + } + py_frame = PyFrame_New( + PyThreadState_GET(), /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + py_frame->f_lineno = py_line; + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) return __pyx_pw_5numpy_7ndarray_1__getbuffer__(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if (PyObject_TypeCheck(obj, __pyx_ptype_5numpy_ndarray)) { __pyx_pw_5numpy_7ndarray_3__releasebuffer__(obj, view); return; } + Py_DECREF(obj); + view->obj = NULL; +} +#endif + + + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +#if CYTHON_USE_PYLONG_INTERNALS + #include "longintrepr.h" +#endif + +static CYTHON_INLINE MUMPS_INT __Pyx_PyInt_As_MUMPS_INT(PyObject *x) { + const MUMPS_INT neg_one = (MUMPS_INT) -1, const_zero = (MUMPS_INT) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(MUMPS_INT) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (MUMPS_INT) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, digits[0]) + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) >= 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (MUMPS_INT) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (MUMPS_INT) 0; + case -1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(MUMPS_INT, digit, +digits[0]) + case -2: + if (8 * sizeof(MUMPS_INT) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(MUMPS_INT) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(MUMPS_INT) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(MUMPS_INT) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(MUMPS_INT) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) (((MUMPS_INT)-1)*(((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(MUMPS_INT) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(MUMPS_INT, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(MUMPS_INT) - 1 > 4 * PyLong_SHIFT) { + return (MUMPS_INT) ((((((((((MUMPS_INT)digits[3]) << PyLong_SHIFT) | (MUMPS_INT)digits[2]) << PyLong_SHIFT) | (MUMPS_INT)digits[1]) << PyLong_SHIFT) | (MUMPS_INT)digits[0]))); + } + } + break; + } +#endif + if (sizeof(MUMPS_INT) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, long, PyLong_AsLong(x)) + } else if (sizeof(MUMPS_INT) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(MUMPS_INT, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + MUMPS_INT val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (MUMPS_INT) -1; + } + } else { + MUMPS_INT val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (MUMPS_INT) -1; + val = __Pyx_PyInt_As_MUMPS_INT(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to MUMPS_INT"); + return (MUMPS_INT) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to MUMPS_INT"); + return (MUMPS_INT) -1; +} + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eqf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sumf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_difff(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prodf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quotf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_negf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zerof(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conjf(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_absf(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_powf(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(a, a); + case 3: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, a); + case 4: + z = __Pyx_c_prodf(a, a); + return __Pyx_c_prodf(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_absf(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif +#endif + +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif +#else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } +#endif + +#if CYTHON_CCOMPLEX +#else + static CYTHON_INLINE int __Pyx_c_eq(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double denom = b.real * b.real + b.imag * b.imag; + z.real = (a.real * b.real + a.imag * b.imag) / denom; + z.imag = (a.imag * b.real - a.real * b.imag) / denom; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(a, a); + case 3: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, a); + case 4: + z = __Pyx_c_prod(a, a); + return __Pyx_c_prod(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } + r = a.real; + theta = 0; + } else { + r = __Pyx_c_abs(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif +#endif + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { + const int neg_one = (int) -1, const_zero = (int) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_enum__NPY_TYPES(enum NPY_TYPES value) { + const enum NPY_TYPES neg_one = (enum NPY_TYPES) -1, const_zero = (enum NPY_TYPES) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(enum NPY_TYPES) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(enum NPY_TYPES) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(enum NPY_TYPES) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(enum NPY_TYPES), + little, !is_unsigned); + } +} + +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { + const long neg_one = (long) -1, const_zero = (long) 0; + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, -(sdigit) digits[0]) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_Int(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_Int(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +static int __Pyx_check_binary_version(void) { + char ctversion[4], rtversion[4]; + PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); + if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +#ifndef __PYX_HAVE_RT_ImportModule +#define __PYX_HAVE_RT_ImportModule +static PyObject *__Pyx_ImportModule(const char *name) { + PyObject *py_name = 0; + PyObject *py_module = 0; + py_name = __Pyx_PyIdentifier_FromString(name); + if (!py_name) + goto bad; + py_module = PyImport_Import(py_name); + Py_DECREF(py_name); + return py_module; +bad: + Py_XDECREF(py_name); + return 0; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportType +#define __PYX_HAVE_RT_ImportType +static PyTypeObject *__Pyx_ImportType(const char *module_name, const char *class_name, + size_t size, int strict) +{ + PyObject *py_module = 0; + PyObject *result = 0; + PyObject *py_name = 0; + char warning[200]; + Py_ssize_t basicsize; +#ifdef Py_LIMITED_API + PyObject *py_basicsize; +#endif + py_module = __Pyx_ImportModule(module_name); + if (!py_module) + goto bad; + py_name = __Pyx_PyIdentifier_FromString(class_name); + if (!py_name) + goto bad; + result = PyObject_GetAttr(py_module, py_name); + Py_DECREF(py_name); + py_name = 0; + Py_DECREF(py_module); + py_module = 0; + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#ifndef Py_LIMITED_API + basicsize = ((PyTypeObject *)result)->tp_basicsize; +#else + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (!strict && (size_t)basicsize > size) { + PyOS_snprintf(warning, sizeof(warning), + "%s.%s size changed, may indicate binary incompatibility", + module_name, class_name); + if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; + } + else if ((size_t)basicsize != size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s has the wrong size, try recompiling", + module_name, class_name); + goto bad; + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(py_module); + Py_XDECREF(result); + return NULL; +} +#endif + +#ifndef __PYX_HAVE_RT_ImportFunction +#define __PYX_HAVE_RT_ImportFunction +static int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) { + PyObject *d = 0; + PyObject *cobj = 0; + union { + void (*fp)(void); + void *p; + } tmp; + d = PyObject_GetAttrString(module, (char *)"__pyx_capi__"); + if (!d) + goto bad; + cobj = PyDict_GetItemString(d, funcname); + if (!cobj) { + PyErr_Format(PyExc_ImportError, + "%.200s does not export expected C function %.200s", + PyModule_GetName(module), funcname); + goto bad; + } +#if PY_VERSION_HEX >= 0x02070000 + if (!PyCapsule_IsValid(cobj, sig)) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj)); + goto bad; + } + tmp.p = PyCapsule_GetPointer(cobj, sig); +#else + {const char *desc, *s1, *s2; + desc = (const char *)PyCObject_GetDesc(cobj); + if (!desc) + goto bad; + s1 = desc; s2 = sig; + while (*s1 != '\0' && *s1 == *s2) { s1++; s2++; } + if (*s1 != *s2) { + PyErr_Format(PyExc_TypeError, + "C function %.200s.%.200s has wrong signature (expected %.500s, got %.500s)", + PyModule_GetName(module), funcname, sig, desc); + goto bad; + } + tmp.p = PyCObject_AsVoidPtr(cobj);} +#endif + *f = tmp.fp; + if (!(*f)) + goto bad; + Py_DECREF(d); + return 0; +bad: + Py_XDECREF(d); + return -1; +} +#endif + +static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +static CYTHON_INLINE char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if CYTHON_COMPILING_IN_CPYTHON && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { +#if PY_VERSION_HEX < 0x03030000 + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +#else + if (__Pyx_PyUnicode_READY(o) == -1) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (PyUnicode_IS_ASCII(o)) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Int(PyObject* x) { + PyNumberMethods *m; + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (PyInt_Check(x) || PyLong_Check(x)) +#else + if (PyLong_Check(x)) +#endif + return __Pyx_NewRef(x); + m = Py_TYPE(x)->tp_as_number; +#if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = PyNumber_Long(x); + } +#else + if (m && m->nb_int) { + name = "int"; + res = PyNumber_Long(x); + } +#endif + if (res) { +#if PY_MAJOR_VERSION < 3 + if (!PyInt_Check(res) && !PyLong_Check(res)) { +#else + if (!PyLong_Check(res)) { +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + name, name, Py_TYPE(res)->tp_name); + Py_DECREF(res); + return NULL; + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(x); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/mumps/src/numpy_mumps_INT32_FLOAT64.pxd b/mumps/src/numpy_mumps_INT32_FLOAT64.pxd new file mode 100644 index 0000000..a70a183 --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_FLOAT64.pxd @@ -0,0 +1,13 @@ +from mumps.src.mumps_INT32_FLOAT64 cimport BaseMUMPSSolver_INT32_FLOAT64, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_FLOAT64 cimport DMUMPS_COMPLEX + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + + +cdef class NumpyMUMPSSolver_INT32_FLOAT64(BaseMUMPSSolver_INT32_FLOAT64): + cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + cnp.ndarray[MUMPS_INT, ndim=1] acol, + cnp.ndarray[DMUMPS_COMPLEX, ndim=1] aval) \ No newline at end of file diff --git a/mumps/src/numpy_mumps_INT32_FLOAT64.pyx b/mumps/src/numpy_mumps_INT32_FLOAT64.pyx new file mode 100644 index 0000000..c24dc41 --- /dev/null +++ b/mumps/src/numpy_mumps_INT32_FLOAT64.pyx @@ -0,0 +1,56 @@ +from mumps.src.mumps_INT32_FLOAT64 cimport BaseMUMPSSolver_INT32_FLOAT64, c_to_fortran_index_array, MUMPS_INT +from mumps.src.mumps_INT32_FLOAT64 cimport DMUMPS_COMPLEX + +import numpy as np +cimport numpy as cnp + +cnp.import_array() + + +cdef class NumpyMUMPSSolver_INT32_FLOAT64(BaseMUMPSSolver_INT32_FLOAT64): + """ + MUMPS Context. + + Only deals with Numpy arrays. + + We follow the common use of MUMPS. In particular, we use the same names for the methods of this + class as their corresponding counter-parts in MUMPS. + + Warning: if the numpy arrays are modified externally by the user between 2 calls to solve, + the changes in arrays won't be passed to MUMPS. + """ + def __cinit__(self, MUMPS_INT n, MUMPS_INT nnz, + comm_fortran=-987654, sym=False, verbose=False): + """ + Args: + n: size of matrix A + nnz: number of non zero elements of matrix A + comm_fortran: MPI communicator + sym: a boolean indicating if A is a symmetric matrix or not + verbose: a boolean to turn on or off the verbosity of MUMPS + + Warning: if the numpy arrays are modified externally by the user between 2 calls to solve, + the changes in arrays won't be passed to MUMPS. + """ + pass + + cpdef get_matrix_data(self, cnp.ndarray[MUMPS_INT, ndim=1] arow, + cnp.ndarray[MUMPS_INT, ndim=1] acol, + cnp.ndarray[DMUMPS_COMPLEX, ndim=1] aval): + """ + + Args: + arow: row indices of non zero elements of A + acol: column indices of non zero elements of A + aval: values of non zeros elements of A + + Note: we keep the same name for this method in all derived classes. + """ + + assert arow.shape[0] == self.nnz + assert acol.shape[0] == self.nnz + assert aval.shape[0] == self.nnz + + self.get_data_pointers( cnp.PyArray_DATA(arow), + cnp.PyArray_DATA(acol), + cnp.PyArray_DATA(aval)) \ No newline at end of file diff --git a/release.sh b/release.sh deleted file mode 100644 index d22a5eb..0000000 --- a/release.sh +++ /dev/null @@ -1,38 +0,0 @@ -#!/bin/sh -# -# Runs before git flow release finish - -git branch -D without-cython -git push origin --delete without-cython -git checkout -b without-cython - -git rm --cached \*.cpy -git rm --cached \*.cpx -git rm --cached \*.cpd -git rm --cached generate_code.py -git rm --cached release.sh - -mv .gitignore /tmp/.gitignore-qr_mumps - -cp config/site.template.cython.cfg site.cfg - -python generate_code.py -c -python generate_code.py -python setup.py install - -git add \*.c -git rm --cached -r build -git rm --cached -r config - -cp config/site.template.cfg . -cp config/.gitignore . -cp config/.travis.yml . - -git add tests/\*.py -git add setup.py -git add --all - -git commit -m "c files from last commit in develop" -git push --set-upstream origin without-cython -git checkout develop - diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..c80d86b --- /dev/null +++ b/setup.py @@ -0,0 +1,294 @@ +#!/usr/bin/env python + +# The file setup.py is automatically generated +# Generate it with +# python generate_code -s + +from distutils.core import setup +from setuptools import find_packages +from distutils.extension import Extension + +import numpy as np + +import ConfigParser +import os +import copy + +from codecs import open +from os import path + +# HELPERS +#-------- +def prepare_Cython_extensions_as_C_extensions(extensions): + """ + Modify the list of sources to transform `Cython` extensions into `C` extensions. + Args: + extensions: A list of (`Cython`) `distutils` extensions. + Warning: + The extensions are changed in place. This function is not compatible with `C++` code. + Note: + Only `Cython` source files are modified into their `C` equivalent source files. Other file types are unchanged. + """ + for extension in extensions: + c_sources = list() + for source_path in extension.sources: + path, source = os.path.split(source_path) + filename, ext = os.path.splitext(source) + + if ext == '.pyx': + c_sources.append(os.path.join(path, filename + '.c')) + elif ext in ['.pxd', '.pxi']: + pass + else: + # copy source as is + c_sources.append(source_path) + + # modify extension in place + extension.sources = c_sources + +mumps_config = ConfigParser.SafeConfigParser() +mumps_config.read('site.cfg') + +version = {} +with open("mumps/version.py") as fp: + exec(fp.read(), version) +# later on we use: version['version'] + +numpy_include = np.get_include() + +# Use Cython? +use_cython = mumps_config.getboolean('CODE_GENERATION', 'use_cython') +if use_cython: + try: + from Cython.Distutils import build_ext + from Cython.Build import cythonize + except ImportError: + raise ImportError("Check '%s': Cython is not properly installed." % mumps_config_file) + +# DEFAULT +default_include_dir = mumps_config.get('DEFAULT', 'include_dirs').split(os.pathsep) +default_library_dir = mumps_config.get('DEFAULT', 'library_dirs').split(os.pathsep) + +# mumps +mumps_compiled_in_64bits = mumps_config.getboolean('MUMPS', 'mumps_compiled_in_64bits') + +# Debug mode +use_debug_symbols = mumps_config.getboolean('CODE_GENERATION', 'use_debug_symbols') + +# find user defined directories +mumps_include_dirs = mumps_config.get('MUMPS', 'include_dirs').split(os.pathsep) +if mumps_include_dirs == '': + mumps_include_dirs = default_include_dir +mumps_library_dirs = mumps_config.get('MUMPS', 'library_dirs').split(os.pathsep) +if mumps_library_dirs == '': + mumps_library_dirs = default_library_dir + +# OPTIONAL +build_cysparse_ext = False +if mumps_config.has_section('CYSPARSE'): + build_cysparse_ext = True + cysparse_rootdir = mumps_config.get('CYSPARSE', 'cysparse_rootdir').split(os.pathsep) + if cysparse_rootdir == '': + raise ValueError("You must specify where CySparse source code is" + + "located. Use `cysparse_rootdir` to specify its path.") + + +######################################################################################################################## +# EXTENSIONS +######################################################################################################################## +include_dirs = [numpy_include, '.'] + +ext_params = {} +ext_params['include_dirs'] = include_dirs +if not use_debug_symbols: + ext_params['extra_compile_args'] = ["-O2", '-std=c99', '-Wno-unused-function'] + ext_params['extra_link_args'] = [] +else: + ext_params['extra_compile_args'] = ["-g", '-std=c99', '-Wno-unused-function'] + ext_params['extra_link_args'] = ["-g"] + +context_ext_params = copy.deepcopy(ext_params) +mumps_ext = [] +base_ext_params_INT32_COMPLEX64 = copy.deepcopy(ext_params) +base_ext_params_INT32_COMPLEX64['include_dirs'].extend(mumps_include_dirs) +base_ext_params_INT32_COMPLEX64['library_dirs'] = mumps_library_dirs +base_ext_params_INT32_COMPLEX64['libraries'] = [] # 'scalapack', 'pord'] +base_ext_params_INT32_COMPLEX64['libraries'].append('cmumps') +base_ext_params_INT32_COMPLEX64['libraries'].append('mumps_common') +base_ext_params_INT32_COMPLEX64['libraries'].append('pord') +base_ext_params_INT32_COMPLEX64['libraries'].append('mpiseq') +base_ext_params_INT32_COMPLEX64['libraries'].append('blas') +base_ext_params_INT32_COMPLEX64['libraries'].append('pthread') + +mumps_ext.append(Extension(name="mumps.src.mumps_INT32_COMPLEX64", + sources=['mumps/src/mumps_INT32_COMPLEX64.pxd', + 'mumps/src/mumps_INT32_COMPLEX64.pyx'], + **base_ext_params_INT32_COMPLEX64)) + +numpy_ext_params_INT32_COMPLEX64 = copy.deepcopy(ext_params) +numpy_ext_params_INT32_COMPLEX64['include_dirs'].extend(mumps_include_dirs) +mumps_ext.append(Extension(name="mumps.src.numpy_mumps_INT32_COMPLEX64", + sources=['mumps/src/numpy_mumps_INT32_COMPLEX64.pxd', + 'mumps/src/numpy_mumps_INT32_COMPLEX64.pyx'], + **numpy_ext_params_INT32_COMPLEX64)) + +base_ext_params_INT32_COMPLEX128 = copy.deepcopy(ext_params) +base_ext_params_INT32_COMPLEX128['include_dirs'].extend(mumps_include_dirs) +base_ext_params_INT32_COMPLEX128['library_dirs'] = mumps_library_dirs +base_ext_params_INT32_COMPLEX128['libraries'] = [] # 'scalapack', 'pord'] +base_ext_params_INT32_COMPLEX128['libraries'].append('zmumps') +base_ext_params_INT32_COMPLEX128['libraries'].append('mumps_common') +base_ext_params_INT32_COMPLEX128['libraries'].append('pord') +base_ext_params_INT32_COMPLEX128['libraries'].append('mpiseq') +base_ext_params_INT32_COMPLEX128['libraries'].append('blas') +base_ext_params_INT32_COMPLEX128['libraries'].append('pthread') + +mumps_ext.append(Extension(name="mumps.src.mumps_INT32_COMPLEX128", + sources=['mumps/src/mumps_INT32_COMPLEX128.pxd', + 'mumps/src/mumps_INT32_COMPLEX128.pyx'], + **base_ext_params_INT32_COMPLEX128)) + +numpy_ext_params_INT32_COMPLEX128 = copy.deepcopy(ext_params) +numpy_ext_params_INT32_COMPLEX128['include_dirs'].extend(mumps_include_dirs) +mumps_ext.append(Extension(name="mumps.src.numpy_mumps_INT32_COMPLEX128", + sources=['mumps/src/numpy_mumps_INT32_COMPLEX128.pxd', + 'mumps/src/numpy_mumps_INT32_COMPLEX128.pyx'], + **numpy_ext_params_INT32_COMPLEX128)) + +base_ext_params_INT32_FLOAT32 = copy.deepcopy(ext_params) +base_ext_params_INT32_FLOAT32['include_dirs'].extend(mumps_include_dirs) +base_ext_params_INT32_FLOAT32['library_dirs'] = mumps_library_dirs +base_ext_params_INT32_FLOAT32['libraries'] = [] # 'scalapack', 'pord'] +base_ext_params_INT32_FLOAT32['libraries'].append('smumps') +base_ext_params_INT32_FLOAT32['libraries'].append('mumps_common') +base_ext_params_INT32_FLOAT32['libraries'].append('pord') +base_ext_params_INT32_FLOAT32['libraries'].append('mpiseq') +base_ext_params_INT32_FLOAT32['libraries'].append('blas') +base_ext_params_INT32_FLOAT32['libraries'].append('pthread') + +mumps_ext.append(Extension(name="mumps.src.mumps_INT32_FLOAT32", + sources=['mumps/src/mumps_INT32_FLOAT32.pxd', + 'mumps/src/mumps_INT32_FLOAT32.pyx'], + **base_ext_params_INT32_FLOAT32)) + +numpy_ext_params_INT32_FLOAT32 = copy.deepcopy(ext_params) +numpy_ext_params_INT32_FLOAT32['include_dirs'].extend(mumps_include_dirs) +mumps_ext.append(Extension(name="mumps.src.numpy_mumps_INT32_FLOAT32", + sources=['mumps/src/numpy_mumps_INT32_FLOAT32.pxd', + 'mumps/src/numpy_mumps_INT32_FLOAT32.pyx'], + **numpy_ext_params_INT32_FLOAT32)) + +base_ext_params_INT32_FLOAT64 = copy.deepcopy(ext_params) +base_ext_params_INT32_FLOAT64['include_dirs'].extend(mumps_include_dirs) +base_ext_params_INT32_FLOAT64['library_dirs'] = mumps_library_dirs +base_ext_params_INT32_FLOAT64['libraries'] = [] # 'scalapack', 'pord'] +base_ext_params_INT32_FLOAT64['libraries'].append('dmumps') +base_ext_params_INT32_FLOAT64['libraries'].append('mumps_common') +base_ext_params_INT32_FLOAT64['libraries'].append('pord') +base_ext_params_INT32_FLOAT64['libraries'].append('mpiseq') +base_ext_params_INT32_FLOAT64['libraries'].append('blas') +base_ext_params_INT32_FLOAT64['libraries'].append('pthread') + +mumps_ext.append(Extension(name="mumps.src.mumps_INT32_FLOAT64", + sources=['mumps/src/mumps_INT32_FLOAT64.pxd', + 'mumps/src/mumps_INT32_FLOAT64.pyx'], + **base_ext_params_INT32_FLOAT64)) + +numpy_ext_params_INT32_FLOAT64 = copy.deepcopy(ext_params) +numpy_ext_params_INT32_FLOAT64['include_dirs'].extend(mumps_include_dirs) +mumps_ext.append(Extension(name="mumps.src.numpy_mumps_INT32_FLOAT64", + sources=['mumps/src/numpy_mumps_INT32_FLOAT64.pxd', + 'mumps/src/numpy_mumps_INT32_FLOAT64.pyx'], + **numpy_ext_params_INT32_FLOAT64)) + + +if build_cysparse_ext: + cysparse_ext_params_INT32_COMPLEX64 = copy.deepcopy(ext_params) + cysparse_ext_params_INT32_COMPLEX64['include_dirs'].extend(cysparse_rootdir) + cysparse_ext_params_INT32_COMPLEX64['include_dirs'].extend(mumps_include_dirs) + mumps_ext.append(Extension(name="mumps.src.cysparse_mumps_INT32_COMPLEX64", + sources=['mumps/src/cysparse_mumps_INT32_COMPLEX64.pxd', + 'mumps/src/cysparse_mumps_INT32_COMPLEX64.pyx'], + **cysparse_ext_params_INT32_COMPLEX64)) + + cysparse_ext_params_INT32_COMPLEX128 = copy.deepcopy(ext_params) + cysparse_ext_params_INT32_COMPLEX128['include_dirs'].extend(cysparse_rootdir) + cysparse_ext_params_INT32_COMPLEX128['include_dirs'].extend(mumps_include_dirs) + mumps_ext.append(Extension(name="mumps.src.cysparse_mumps_INT32_COMPLEX128", + sources=['mumps/src/cysparse_mumps_INT32_COMPLEX128.pxd', + 'mumps/src/cysparse_mumps_INT32_COMPLEX128.pyx'], + **cysparse_ext_params_INT32_COMPLEX128)) + + cysparse_ext_params_INT32_FLOAT32 = copy.deepcopy(ext_params) + cysparse_ext_params_INT32_FLOAT32['include_dirs'].extend(cysparse_rootdir) + cysparse_ext_params_INT32_FLOAT32['include_dirs'].extend(mumps_include_dirs) + mumps_ext.append(Extension(name="mumps.src.cysparse_mumps_INT32_FLOAT32", + sources=['mumps/src/cysparse_mumps_INT32_FLOAT32.pxd', + 'mumps/src/cysparse_mumps_INT32_FLOAT32.pyx'], + **cysparse_ext_params_INT32_FLOAT32)) + + cysparse_ext_params_INT32_FLOAT64 = copy.deepcopy(ext_params) + cysparse_ext_params_INT32_FLOAT64['include_dirs'].extend(cysparse_rootdir) + cysparse_ext_params_INT32_FLOAT64['include_dirs'].extend(mumps_include_dirs) + mumps_ext.append(Extension(name="mumps.src.cysparse_mumps_INT32_FLOAT64", + sources=['mumps/src/cysparse_mumps_INT32_FLOAT64.pxd', + 'mumps/src/cysparse_mumps_INT32_FLOAT64.pyx'], + **cysparse_ext_params_INT32_FLOAT64)) + + + +packages_list = ['mumps', 'mumps.src', 'tests'] + + +# PACKAGE PREPARATION FOR EXCLUSIVE C EXTENSIONS +######################################################################################################################## +# We only use the C files **without** Cython. In fact, Cython doesn't need to be installed. +if not use_cython: + prepare_Cython_extensions_as_C_extensions(mumps_ext) + +CLASSIFIERS = """\ +Development Status :: 4 - Beta +Intended Audience :: Science/Research +Intended Audience :: Developers +License :: OSI Approved +Programming Language :: Python +Programming Language :: Cython +Topic :: Software Development +Topic :: Scientific/Engineering +Operating System :: POSIX +Operating System :: Unix +Operating System :: MacOS :: MacOS X +Natural Language :: English +""" + +here = path.abspath(path.dirname(__file__)) +# Get the long description from the relevant file +with open(path.join(here, 'DESCRIPTION.rst'), encoding='utf-8') as f: + long_description = f.read() + +setup_args = { + 'name' : 'MUMPS.py', + 'version' : version['version'], + 'description' : 'A python interface to MUMPS.', + 'long_description' : long_description, + #Author details + + 'author' : 'Sylvain Arreckx, Dominique Orban and Nikolaj van Omme', + 'maintainer' : "Sylvain Arreckx", + + 'maintainer_email' : "sylvain.arreckx@gmail.com", + 'summary' : "A Cython/Python interface to the MUMPS solver.", + 'url' : "https://github.com/PythonOptimizers/MUMPS.py.git", + 'download_url' : "https://github.com/PythonOptimizers/MUMPS.py.git", + 'license' : 'LGPL', + 'classifiers' : filter(None, CLASSIFIERS.split('\n')), + 'install_requires' : ['numpy'], + 'ext_modules' : mumps_ext, + 'package_dir' : {"mumps": "mumps"}, + 'packages' : packages_list, + 'zip_safe' : False} + +if use_cython: + setup_args['cmdclass'] = {'build_ext': build_ext} + +setup(**setup_args) \ No newline at end of file diff --git a/site.template.cfg b/site.template.cfg index 67cba45..b0099a4 100644 --- a/site.template.cfg +++ b/site.template.cfg @@ -31,7 +31,7 @@ file_log_level = DEBUG # if left blank, we use INT64_t on 64 bits platforms and INT32_t on 32 bits platforms DEFAULT_INDEX_TYPE = # Do you want to generate the .c files from Cython? -use_cython = true +use_cython = false # Use debug symbols? use_debug_symbols = false diff --git a/tests/test_mumps_with_cysparse.cpy b/tests/test_mumps_with_cysparse.cpy deleted file mode 100644 index aaa5efa..0000000 --- a/tests/test_mumps_with_cysparse.cpy +++ /dev/null @@ -1,89 +0,0 @@ -#!/usr/bin/env python - -""" -This file tests basic umfpack operations on **all** types supported by MUMPS -and on symmetric and general matrices. -""" -from cysparse.sparse.ll_mat import * -import cysparse.common_types.cysparse_types as types - -from mumps.mumps_context import MUMPSContext -import numpy as np -from numpy.testing import * -import sys - - -{% for index_type in index_list %} - {% for element_type in type_list %} -class CySparseMUMPSContextTestCase_@index_type@_@element_type@(TestCase): - def setUp(self): - self.n = 4 - arow = np.array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3], dtype=np.@index_type|lower@) - acol = np.array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=np.@index_type|lower@) - aval = np.array([1, 2, 3, 4, 5, 0, 7, 8, 9, 10, 0, 12, 13, 14, 15, 0], dtype=np.@element_type|lower@) - self.sym = False - self.A = LLSparseMatrix(size=self.n, itype=types.@index_type@_T, dtype=types.@element_type@_T) - self.A.put_triplet(arow, acol, aval) - - def test_init(self): - context = MUMPSContext(self.A, verbose=False) - assert_equal(self.sym, context.sym) - - def test_analyze(self): - context = MUMPSContext(self.A, verbose=False) - context.analyze() - assert(context.analyzed==True) - - def test_factorize(self): - context = MUMPSContext(self.A, verbose=False) - context.factorize() - assert(context.analyzed==True) - assert(context.factorized==True) - - def test_dense_solve_single_rhs(self): - context = MUMPSContext(self.A, verbose=False) - context.factorize() - e = np.ones(self.n, dtype=np.@element_type|lower@) - rhs = self.A * e - x = context.solve(rhs=rhs) - assert_almost_equal(x,e) - - def test_dense_solve_multiple_rhs(self): - context = MUMPSContext(self.A, verbose=False) - context.factorize() - B = np.ones([self.n, 3], dtype=np.@element_type|lower@) - B[: ,1] = 2 * B[:,1] - B[: ,2] = 3 * B[:,2] - rhs = np.ones([self.n, 3], dtype=np.@element_type|lower@) - rhs[:, 0] = self.A * B[:, 0] - rhs[:, 1] = self.A * B[:, 1] - rhs[:, 2] = self.A * B[:, 2] - x = context.solve(rhs=rhs) - assert_almost_equal(x,B,6) - - def test_sparse_solve_multiple_rhs(self): - context = MUMPSContext(self.A, verbose=False) - context.factorize() - acol_csc = np.array([1,5,9,13,17], dtype=np.@index_type|lower@)-1 - arow_csc = np.array([1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4], dtype=np.@index_type|lower@)-1 - aval_csc = np.array([1,5,9,13,2,0,10,14,3,7,0,15,4,8,12,0], dtype=np.@element_type|lower@) - x = context.solve(rhs_col_ptr=acol_csc, rhs_row_ind=arow_csc, rhs_val=aval_csc) - assert_almost_equal(x,np.eye(4),6) - - - def test_iterative_refinement_single_rhs(self): - context = MUMPSContext(self.A, verbose=False) - context.factorize() - e = np.ones(self.n, dtype=np.@element_type|lower@) - rhs = self.A * e - x = context.solve(rhs=rhs) - x = context.refine(rhs, 3) - assert_almost_equal(x,e) - - - {% endfor %} -{% endfor %} - -if __name__ == "__main__": - run_module_suite() - diff --git a/tests/test_mumps_with_numpy.cpy b/tests/test_mumps_with_numpy.cpy deleted file mode 100644 index 083decb..0000000 --- a/tests/test_mumps_with_numpy.cpy +++ /dev/null @@ -1,82 +0,0 @@ -#!/usr/bin/env python - -""" -This file tests basic umfpack operations on **all** types supported by MUMPS -and on symmetric and general matrices. -""" - -from mumps.mumps_context import MUMPSContext -import numpy as np -from numpy.testing import * -import sys - - -{% for index_type in index_list %} - {% for element_type in type_list %} -class NumpyMUMPSContextTestCase_@index_type@_@element_type@(TestCase): - def setUp(self): - self.n = 4 - self.A = np.array([[1, 2, 3, 4], [5, 0, 7, 8], [9, 10, 0, 12], [13, 14, 15, 0]], dtype=np.@element_type|lower@) - self.arow = np.array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3], dtype=np.@index_type|lower@) - self.acol = np.array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=np.@index_type|lower@) - self.aval = np.array([1, 2, 3, 4, 5, 0, 7, 8, 9, 10, 0, 12, 13, 14, 15, 0], dtype=np.@element_type|lower@) - self.sym = False - - def test_init(self): - context = MUMPSContext((self.n, self.arow, self.acol, self.aval, self.sym), verbose=False) - assert_equal(self.sym, context.sym) - - def test_analyze(self): - context = MUMPSContext((self.n, self.arow, self.acol, self.aval, self.sym), verbose=False) - context.analyze() - assert(context.analyzed==True) - - def test_factorize(self): - context = MUMPSContext((self.n, self.arow, self.acol, self.aval, self.sym), verbose=False) - context.factorize() - assert(context.analyzed==True) - assert(context.factorized==True) - - def test_dense_solve_single_rhs(self): - context = MUMPSContext((self.n, self.arow, self.acol, self.aval, self.sym), verbose=False) - context.factorize() - e = np.ones(self.n, dtype=np.@element_type|lower@) - rhs = np.dot(self.A, e) - x = context.solve(rhs=rhs) - assert_almost_equal(x,e) - - def test_dense_solve_multiple_rhs(self): - context = MUMPSContext((self.n, self.arow, self.acol, self.aval, self.sym), verbose=False) - context.factorize() - B = np.ones([self.n, 3], dtype=np.@element_type|lower@) - B[: ,1] = 2 * B[:,1] - B[: ,2] = 3 * B[:,2] - rhs = np.dot(self.A,B) - x = context.solve(rhs=rhs) - assert_almost_equal(x,B,6) - - def test_sparse_solve_multiple_rhs(self): - context = MUMPSContext((self.n, self.arow, self.acol, self.aval, self.sym), verbose=False) - context.factorize() - acol_csc = np.array([1,5,9,13,17], - dtype=np.@index_type|lower@)-1 - arow_csc = np.array([1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4], dtype=np.@index_type|lower@)-1 - aval_csc = np.array([1,5,9,13,2,0,10,14,3,7,0,15,4,8,12,0], dtype=np.@element_type|lower@) - x = context.solve(rhs_col_ptr=acol_csc, rhs_row_ind=arow_csc, rhs_val=aval_csc) - assert_almost_equal(x,np.eye(4),6) - - def test_iterative_refinement_single_rhs(self): - context = MUMPSContext((self.n, self.arow, self.acol, self.aval, self.sym), verbose=False) - context.factorize() - e = np.ones(self.n, dtype=np.@element_type|lower@) - rhs = np.dot(self.A, e) - x = context.solve(rhs=rhs) - x = context.refine(rhs, 3) - assert_almost_equal(x,e) - - - {% endfor %} -{% endfor %} - -if __name__ == "__main__": - run_module_suite()