/* ========================================================================== */
  /* === umf_version.h ======================================================== */
  /* ========================================================================== */
  
  /* -------------------------------------------------------------------------- */
  /* UMFPACK Copyright (c) Timothy A. Davis, CISE,                              */
  /* Univ. of Florida.  All Rights Reserved.  See ../Doc/License for License.   */
  /* web: http://www.cise.ufl.edu/research/sparse/umfpack                       */
  /* -------------------------------------------------------------------------- */
  
  /*
     Define routine names, depending on version being compiled.
  
     DINT:	double precision, int's as integers
     DLONG:	double precision, UF_long's as integers
     ZLONG:	complex double precision, UF_long's as integers
     ZINT:	complex double precision, int's as integers
  */
  
  /* Set DINT as the default, if nothing is defined */
  #if !defined (DLONG) && !defined (DINT) && !defined (ZLONG) && !defined (ZINT)
  #define DINT
  #endif
  
  /* Determine if this is a real or complex version */
  #if defined (ZLONG) || defined (ZINT)
  #define COMPLEX
  #endif
  
  /* -------------------------------------------------------------------------- */
  /* integer type (Int is int or UF_long) now defined in amd_internal.h */
  /* -------------------------------------------------------------------------- */
  
  #if defined (DLONG) || defined (ZLONG)
  #define LONG_INTEGER
  #endif
  
  /* -------------------------------------------------------------------------- */
  /* Numerical relop macros for correctly handling the NaN case */
  /* -------------------------------------------------------------------------- */
  
  /*
  SCALAR_IS_NAN(x):
      True if x is NaN.  False otherwise.  The commonly-existing isnan(x)
      function could be used, but it's not in Kernighan & Ritchie 2nd edition
      (ANSI C).  It may appear in <math.h>, but I'm not certain about
      portability.  The expression x != x is true if and only if x is NaN,
      according to the IEEE 754 floating-point standard.
  
  SCALAR_IS_ZERO(x):
      True if x is zero.  False if x is nonzero, NaN, or +/- Inf.
      This is (x == 0) if the compiler is IEEE 754 compliant.
  
  SCALAR_IS_NONZERO(x):
      True if x is nonzero, NaN, or +/- Inf.  False if x zero.
      This is (x != 0) if the compiler is IEEE 754 compliant.
  
  SCALAR_IS_LTZERO(x):
      True if x is < zero or -Inf.  False if x is >= 0, NaN, or +Inf.
      This is (x < 0) if the compiler is IEEE 754 compliant.
  */
  
  #if defined (UMF_WINDOWS) && !defined (MATHWORKS)
  
  /* Yes, this is exceedingly ugly.  Blame Microsoft, which hopelessly */
  /* violates the IEEE 754 floating-point standard in a bizarre way. */
  /* If you're using an IEEE 754-compliant compiler, then x != x is true */
  /* iff x is NaN.  For Microsoft, (x < x) is true iff x is NaN. */
  /* So either way, this macro safely detects a NaN. */
  #define SCALAR_IS_NAN(x)	(((x) != (x)) || (((x) < (x))))
  #define SCALAR_IS_ZERO(x)	(((x) == 0.) && !SCALAR_IS_NAN(x))
  #define SCALAR_IS_NONZERO(x)	(((x) != 0.) || SCALAR_IS_NAN(x))
  #define SCALAR_IS_LTZERO(x)	(((x) < 0.) && !SCALAR_IS_NAN(x))
  
  #else
  
  /* These all work properly, according to the IEEE 754 standard ... except on */
  /* a PC with windows.  Works fine in Linux on the same PC... */
  #define SCALAR_IS_NAN(x)	((x) != (x))
  #define SCALAR_IS_ZERO(x)	((x) == 0.)
  #define SCALAR_IS_NONZERO(x)	((x) != 0.)
  #define SCALAR_IS_LTZERO(x)	((x) < 0.)
  
  #endif
  
  /* scalar absolute value macro. If x is NaN, the result is NaN: */
  #define SCALAR_ABS(x) ((SCALAR_IS_LTZERO (x)) ? -(x) : (x))
  
  /* true if an integer (stored in double x) would overflow (or if x is NaN) */
  #define INT_OVERFLOW(x) ((!((x) * (1.0+1e-8) <= (double) Int_MAX)) \
  			|| SCALAR_IS_NAN (x))
  
  /* print a scalar (avoid printing "-0" for negative zero).  */
  #define PRINT_SCALAR(a) \
  { \
      if (SCALAR_IS_NONZERO (a)) \
      { \
  	PRINTF ((" (%g)", (a))) ; \
      } \
      else \
      { \
  	PRINTF ((" (0)")) ; \
      } \
  }
  
  /* -------------------------------------------------------------------------- */
  /* Real floating-point arithmetic */
  /* -------------------------------------------------------------------------- */
  
  #ifndef COMPLEX
  
  #define Entry double
  
  #define SPLIT(s)    		    (1)
  #define REAL_COMPONENT(c)	    (c)
  #define IMAG_COMPONENT(c)	    (0.)
  #define ASSIGN(c,s1,s2,p,split)	    { (c) = (s1)[p] ; }
  #define CLEAR(c)		    { (c) = 0. ; }
  #define CLEAR_AND_INCREMENT(p)	    { *p++ = 0. ; }
  #define IS_NAN(a)		    SCALAR_IS_NAN (a)
  #define IS_ZERO(a)		    SCALAR_IS_ZERO (a)
  #define IS_NONZERO(a)		    SCALAR_IS_NONZERO (a)
  #define SCALE_DIV(c,s)		    { (c) /= (s) ; }
  #define SCALE(c,s)		    { (c) *= (s) ; }
  #define ASSEMBLE(c,a)		    { (c) += (a) ; }
  #define ASSEMBLE_AND_INCREMENT(c,p) { (c) += *p++ ; }
  #define DECREMENT(c,a)		    { (c) -= (a) ; }
  #define MULT(c,a,b)		    { (c) = (a) * (b) ; }
  #define MULT_CONJ(c,a,b)	    { (c) = (a) * (b) ; }
  #define MULT_SUB(c,a,b)		    { (c) -= (a) * (b) ; }
  #define MULT_SUB_CONJ(c,a,b)	    { (c) -= (a) * (b) ; }
  #define DIV(c,a,b)		    { (c) = (a) / (b) ; }
  #define DIV_CONJ(c,a,b)		    { (c) = (a) / (b) ; }
  #define APPROX_ABS(s,a)		    { (s) = SCALAR_ABS (a) ; }
  #define ABS(s,a)		    { (s) = SCALAR_ABS (a) ; }
  #define PRINT_ENTRY(a)		    PRINT_SCALAR (a)
  
  /* for flop counts */
  #define MULTSUB_FLOPS	2.	/* c -= a*b */
  #define DIV_FLOPS	1.	/* c = a/b */
  #define ABS_FLOPS	0.	/* c = abs (a) */
  #define ASSEMBLE_FLOPS	1.	/* c += a */
  #define DECREMENT_FLOPS	1.	/* c -= a */
  #define MULT_FLOPS	1.	/* c = a*b */
  #define SCALE_FLOPS	1.	/* c = a/s */
  
  #else
  
  /* -------------------------------------------------------------------------- */
  /* Complex floating-point arithmetic */
  /* -------------------------------------------------------------------------- */
  
  /*
      Note:  An alternative to this DoubleComplex type would be to use a
      struct { double r ; double i ; }.  The problem with that method
      (used by the Sun Performance Library, for example) is that ANSI C provides
      no guarantee about the layout of a struct.  It is possible that the sizeof
      the struct above would be greater than 2 * sizeof (double).  This would
      mean that the complex BLAS could not be used.  The method used here avoids
      that possibility.  ANSI C *does* guarantee that an array of structs has
      the same size as n times the size of one struct.
  
      The ANSI C99 version of the C language includes a "double _Complex" type.
      It should be possible in that case to do the following:
  
      #define Entry double _Complex
  
      and remove the DoubleComplex struct.  The macros, below, could then be
      replaced with instrinsic operators.  Note that the #define Real and
      #define Imag should also be removed (they only appear in this file).
  
      For the MULT, MULT_SUB, MULT_SUB_CONJ, and MULT_CONJ macros,
      the output argument c cannot be the same as any input argument.
  
  */
  
  typedef struct
  {
      double component [2] ;	/* real and imaginary parts */
  
  } DoubleComplex ;
  
  #define Entry DoubleComplex
  #define Real component [0]
  #define Imag component [1]
  
  /* for flop counts */
  #define MULTSUB_FLOPS	8.	/* c -= a*b */
  #define DIV_FLOPS	9.	/* c = a/b */
  #define ABS_FLOPS	6.	/* c = abs (a), count sqrt as one flop */
  #define ASSEMBLE_FLOPS	2.	/* c += a */
  #define DECREMENT_FLOPS	2.	/* c -= a */
  #define MULT_FLOPS	6.	/* c = a*b */
  #define SCALE_FLOPS	2.	/* c = a/s or c = a*s */
  
  /* -------------------------------------------------------------------------- */
  
  /* real part of c */
  #define REAL_COMPONENT(c) ((c).Real)
  
  /* -------------------------------------------------------------------------- */
  
  /* imag part of c */
  #define IMAG_COMPONENT(c) ((c).Imag)
  
  /* -------------------------------------------------------------------------- */
  
  /* Return TRUE if a complex number is in split form, FALSE if in packed form */
  #define SPLIT(sz) ((sz) != (double *) NULL)
  
  /* -------------------------------------------------------------------------- */
  
  /* c = (s1) + (s2)*i, if s2 is null, then X is in "packed" format (compatible
   * with Entry and ANSI C99 double _Complex type).  */
  #define ASSIGN(c,s1,s2,p,split)	\
  { \
      if (split) \
      { \
          (c).Real = (s1)[p] ; \
          (c).Imag = (s2)[p] ; \
      }  \
      else \
      { \
   	(c) = ((Entry *)(s1))[p] ; \
      }  \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c = 0 */
  #define CLEAR(c) \
  { \
      (c).Real = 0. ; \
      (c).Imag = 0. ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* *p++ = 0 */
  #define CLEAR_AND_INCREMENT(p) \
  { \
      p->Real = 0. ; \
      p->Imag = 0. ; \
      p++ ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* True if a == 0 */
  #define IS_ZERO(a) \
      (SCALAR_IS_ZERO ((a).Real) && SCALAR_IS_ZERO ((a).Imag))
  
  /* -------------------------------------------------------------------------- */
  
  /* True if a is NaN */
  #define IS_NAN(a) \
      (SCALAR_IS_NAN ((a).Real) || SCALAR_IS_NAN ((a).Imag))
  
  /* -------------------------------------------------------------------------- */
  
  /* True if a != 0 */
  #define IS_NONZERO(a) \
      (SCALAR_IS_NONZERO ((a).Real) || SCALAR_IS_NONZERO ((a).Imag))
  
  /* -------------------------------------------------------------------------- */
  
  /* c /= s */
  #define SCALE_DIV(c,s) \
  { \
      (c).Real /= (s) ; \
      (c).Imag /= (s) ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c *= s */
  #define SCALE(c,s) \
  { \
      (c).Real *= (s) ; \
      (c).Imag *= (s) ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c += a */
  #define ASSEMBLE(c,a) \
  { \
      (c).Real += (a).Real ; \
      (c).Imag += (a).Imag ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c += *p++ */
  #define ASSEMBLE_AND_INCREMENT(c,p) \
  { \
      (c).Real += p->Real ; \
      (c).Imag += p->Imag ; \
      p++ ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c -= a */
  #define DECREMENT(c,a) \
  { \
      (c).Real -= (a).Real ; \
      (c).Imag -= (a).Imag ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c = a*b, assert because c cannot be the same as a or b */
  #define MULT(c,a,b) \
  { \
      ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
      (c).Real = (a).Real * (b).Real - (a).Imag * (b).Imag ; \
      (c).Imag = (a).Imag * (b).Real + (a).Real * (b).Imag ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c = a*conjugate(b), assert because c cannot be the same as a or b */
  #define MULT_CONJ(c,a,b) \
  { \
      ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
      (c).Real = (a).Real * (b).Real + (a).Imag * (b).Imag ; \
      (c).Imag = (a).Imag * (b).Real - (a).Real * (b).Imag ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c -= a*b, assert because c cannot be the same as a or b */
  #define MULT_SUB(c,a,b) \
  { \
      ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
      (c).Real -= (a).Real * (b).Real - (a).Imag * (b).Imag ; \
      (c).Imag -= (a).Imag * (b).Real + (a).Real * (b).Imag ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c -= a*conjugate(b), assert because c cannot be the same as a or b */
  #define MULT_SUB_CONJ(c,a,b) \
  { \
      ASSERT (&(c) != &(a) && &(c) != &(b)) ; \
      (c).Real -= (a).Real * (b).Real + (a).Imag * (b).Imag ; \
      (c).Imag -= (a).Imag * (b).Real - (a).Real * (b).Imag ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c = a/b, using function pointer */
  #define DIV(c,a,b) \
  { \
      (void) umfpack_divcomplex ((a).Real, (a).Imag, (b).Real, (b).Imag, \
  	&((c).Real), &((c).Imag)) ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* c = a/conjugate(b), using function pointer */
  #define DIV_CONJ(c,a,b) \
  { \
      (void) umfpack_divcomplex ((a).Real, (a).Imag, (b).Real, (-(b).Imag), \
  	&((c).Real), &((c).Imag)) ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* approximate absolute value, s = |r|+|i| */
  #define APPROX_ABS(s,a) \
  { \
      (s) = SCALAR_ABS ((a).Real) + SCALAR_ABS ((a).Imag) ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* exact absolute value, s = sqrt (a.real^2 + a.imag^2) */
  #define ABS(s,a) \
  { \
      (s) = umfpack_hypot ((a).Real, (a).Imag) ; \
  }
  
  /* -------------------------------------------------------------------------- */
  
  /* print an entry (avoid printing "-0" for negative zero).  */
  #define PRINT_ENTRY(a) \
  { \
      if (SCALAR_IS_NONZERO ((a).Real)) \
      { \
  	PRINTF ((" (%g", (a).Real)) ; \
      } \
      else \
      { \
  	PRINTF ((" (0")) ; \
      } \
      if (SCALAR_IS_LTZERO ((a).Imag)) \
      { \
  	PRINTF ((" - %gi)", -(a).Imag)) ; \
      } \
      else if (SCALAR_IS_ZERO ((a).Imag)) \
      { \
  	PRINTF ((" + 0i)")) ; \
      } \
      else \
      { \
  	PRINTF ((" + %gi)", (a).Imag)) ; \
      } \
  }
  
  /* -------------------------------------------------------------------------- */
  
  #endif	/* #ifndef COMPLEX */
  
  /* -------------------------------------------------------------------------- */
  /* Double precision, with int's as integers */
  /* -------------------------------------------------------------------------- */
  
  #ifdef DINT
  
  #define UMF_analyze		 umf_i_analyze
  #define UMF_apply_order		 umf_i_apply_order
  #define UMF_assemble		 umfdi_assemble
  #define UMF_assemble_fixq	 umfdi_assemble_fixq
  #define UMF_blas3_update	 umfdi_blas3_update
  #define UMF_build_tuples	 umfdi_build_tuples
  #define UMF_build_tuples_usage	 umfdi_build_tuples_usage
  #define UMF_colamd		 umf_i_colamd
  #define UMF_colamd_set_defaults	 umf_i_colamd_set_defaults
  #define UMF_create_element	 umfdi_create_element
  #define UMF_extend_front	 umfdi_extend_front
  #define UMF_free		 umf_i_free
  #define UMF_fsize		 umf_i_fsize
  #define UMF_garbage_collection	 umfdi_garbage_collection
  #define UMF_get_memory		 umfdi_get_memory
  #define UMF_grow_front		 umfdi_grow_front
  #define UMF_init_front		 umfdi_init_front
  #define UMF_is_permutation	 umf_i_is_permutation
  #define UMF_kernel		 umfdi_kernel
  #define UMF_kernel_init		 umfdi_kernel_init
  #define UMF_kernel_init_usage	 umfdi_kernel_init_usage
  #define UMF_kernel_wrapup	 umfdi_kernel_wrapup
  #define UMF_local_search	 umfdi_local_search
  #define UMF_lsolve		 umfdi_lsolve
  #define UMF_ltsolve		 umfdi_ltsolve
  #define UMF_lhsolve		 umfdi_lhsolve
  #define UMF_malloc		 umf_i_malloc
  #define UMF_mem_alloc_element	 umfdi_mem_alloc_element
  #define UMF_mem_alloc_head_block umfdi_mem_alloc_head_block
  #define UMF_mem_alloc_tail_block umfdi_mem_alloc_tail_block
  #define UMF_mem_free_tail_block	 umfdi_mem_free_tail_block
  #define UMF_mem_init_memoryspace umfdi_mem_init_memoryspace
  #define UMF_realloc		 umf_i_realloc
  #define UMF_report_perm		 umf_i_report_perm
  #define UMF_report_vector	 umfdi_report_vector
  #define UMF_row_search		 umfdi_row_search
  #define UMF_scale		 umfdi_scale
  #define UMF_scale_column	 umfdi_scale_column
  #define UMF_set_stats		 umf_i_set_stats
  #define UMF_singletons		 umf_i_singletons
  #define UMF_solve		 umfdi_solve
  #define UMF_start_front		 umfdi_start_front
  #define UMF_store_lu		 umfdi_store_lu
  #define UMF_store_lu_drop	 umfdi_store_lu_drop
  #define UMF_symbolic_usage	 umfdi_symbolic_usage
  #define UMF_transpose		 umfdi_transpose
  #define UMF_tuple_lengths	 umfdi_tuple_lengths
  #define UMF_usolve		 umfdi_usolve
  #define UMF_utsolve		 umfdi_utsolve
  #define UMF_uhsolve		 umfdi_uhsolve
  #define UMF_valid_numeric	 umfdi_valid_numeric
  #define UMF_valid_symbolic	 umfdi_valid_symbolic
  #define UMF_triplet_map_x	 umfdi_triplet_map_x
  #define UMF_triplet_map_nox	 umfdi_triplet_map_nox
  #define UMF_triplet_nomap_x	 umfdi_triplet_nomap_x
  #define UMF_triplet_nomap_nox	 umfdi_triplet_nomap_nox
  #define UMF_2by2		 umfdi_2by2
  
  #define UMFPACK_col_to_triplet	 umfpack_di_col_to_triplet
  #define UMFPACK_defaults	 umfpack_di_defaults
  #define UMFPACK_free_numeric	 umfpack_di_free_numeric
  #define UMFPACK_free_symbolic	 umfpack_di_free_symbolic
  #define UMFPACK_get_lunz	 umfpack_di_get_lunz
  #define UMFPACK_get_numeric	 umfpack_di_get_numeric
  #define UMFPACK_get_symbolic	 umfpack_di_get_symbolic
  #define UMFPACK_get_determinant	 umfpack_di_get_determinant
  #define UMFPACK_numeric		 umfpack_di_numeric
  #define UMFPACK_qsymbolic	 umfpack_di_qsymbolic
  #define UMFPACK_report_control	 umfpack_di_report_control
  #define UMFPACK_report_info	 umfpack_di_report_info
  #define UMFPACK_report_matrix	 umfpack_di_report_matrix
  #define UMFPACK_report_numeric	 umfpack_di_report_numeric
  #define UMFPACK_report_perm	 umfpack_di_report_perm
  #define UMFPACK_report_status	 umfpack_di_report_status
  #define UMFPACK_report_symbolic	 umfpack_di_report_symbolic
  #define UMFPACK_report_triplet	 umfpack_di_report_triplet
  #define UMFPACK_report_vector	 umfpack_di_report_vector
  #define UMFPACK_save_numeric	 umfpack_di_save_numeric
  #define UMFPACK_save_symbolic	 umfpack_di_save_symbolic
  #define UMFPACK_load_numeric	 umfpack_di_load_numeric
  #define UMFPACK_load_symbolic	 umfpack_di_load_symbolic
  #define UMFPACK_scale		 umfpack_di_scale
  #define UMFPACK_solve		 umfpack_di_solve
  #define UMFPACK_symbolic	 umfpack_di_symbolic
  #define UMFPACK_transpose	 umfpack_di_transpose
  #define UMFPACK_triplet_to_col	 umfpack_di_triplet_to_col
  #define UMFPACK_wsolve		 umfpack_di_wsolve
  
  /* for debugging only: */
  #define UMF_malloc_count	 umf_i_malloc_count
  #define UMF_debug		 umfdi_debug
  #define UMF_allocfail		 umfdi_allocfail
  #define UMF_gprob		 umfdi_gprob
  #define UMF_dump_dense		 umfdi_dump_dense
  #define UMF_dump_element	 umfdi_dump_element
  #define UMF_dump_rowcol		 umfdi_dump_rowcol
  #define UMF_dump_matrix		 umfdi_dump_matrix
  #define UMF_dump_current_front	 umfdi_dump_current_front
  #define UMF_dump_lu		 umfdi_dump_lu
  #define UMF_dump_memory		 umfdi_dump_memory
  #define UMF_dump_packed_memory	 umfdi_dump_packed_memory
  #define UMF_dump_col_matrix	 umfdi_dump_col_matrix
  #define UMF_dump_chain		 umfdi_dump_chain
  #define UMF_dump_start		 umfdi_dump_start
  #define UMF_dump_rowmerge	 umfdi_dump_rowmerge
  #define UMF_dump_diagonal_map	 umfdi_dump_diagonal_map
  
  #endif
  
  /* -------------------------------------------------------------------------- */
  /* Double precision, with UF_long's as integers */
  /* -------------------------------------------------------------------------- */
  
  #ifdef DLONG
  
  #define UMF_analyze		 umf_l_analyze
  #define UMF_apply_order		 umf_l_apply_order
  #define UMF_assemble		 umfdl_assemble
  #define UMF_assemble_fixq	 umfdl_assemble_fixq
  #define UMF_blas3_update	 umfdl_blas3_update
  #define UMF_build_tuples	 umfdl_build_tuples
  #define UMF_build_tuples_usage	 umfdl_build_tuples_usage
  #define UMF_colamd		 umf_l_colamd
  #define UMF_colamd_set_defaults	 umf_l_colamd_set_defaults
  #define UMF_create_element	 umfdl_create_element
  #define UMF_extend_front	 umfdl_extend_front
  #define UMF_free		 umf_l_free
  #define UMF_fsize		 umf_l_fsize
  #define UMF_garbage_collection	 umfdl_garbage_collection
  #define UMF_get_memory		 umfdl_get_memory
  #define UMF_grow_front		 umfdl_grow_front
  #define UMF_init_front		 umfdl_init_front
  #define UMF_is_permutation	 umf_l_is_permutation
  #define UMF_kernel		 umfdl_kernel
  #define UMF_kernel_init		 umfdl_kernel_init
  #define UMF_kernel_init_usage	 umfdl_kernel_init_usage
  #define UMF_kernel_wrapup	 umfdl_kernel_wrapup
  #define UMF_local_search	 umfdl_local_search
  #define UMF_lsolve		 umfdl_lsolve
  #define UMF_ltsolve		 umfdl_ltsolve
  #define UMF_lhsolve		 umfdl_lhsolve
  #define UMF_malloc		 umf_l_malloc
  #define UMF_mem_alloc_element	 umfdl_mem_alloc_element
  #define UMF_mem_alloc_head_block umfdl_mem_alloc_head_block
  #define UMF_mem_alloc_tail_block umfdl_mem_alloc_tail_block
  #define UMF_mem_free_tail_block	 umfdl_mem_free_tail_block
  #define UMF_mem_init_memoryspace umfdl_mem_init_memoryspace
  #define UMF_realloc		 umf_l_realloc
  #define UMF_report_perm		 umf_l_report_perm
  #define UMF_report_vector	 umfdl_report_vector
  #define UMF_row_search		 umfdl_row_search
  #define UMF_scale		 umfdl_scale
  #define UMF_scale_column	 umfdl_scale_column
  #define UMF_set_stats		 umf_l_set_stats
  #define UMF_singletons		 umf_l_singletons
  #define UMF_solve		 umfdl_solve
  #define UMF_start_front		 umfdl_start_front
  #define UMF_store_lu		 umfdl_store_lu
  #define UMF_store_lu_drop	 umfdl_store_lu_drop
  #define UMF_symbolic_usage	 umfdl_symbolic_usage
  #define UMF_transpose		 umfdl_transpose
  #define UMF_tuple_lengths	 umfdl_tuple_lengths
  #define UMF_usolve		 umfdl_usolve
  #define UMF_utsolve		 umfdl_utsolve
  #define UMF_uhsolve		 umfdl_uhsolve
  #define UMF_valid_numeric	 umfdl_valid_numeric
  #define UMF_valid_symbolic	 umfdl_valid_symbolic
  #define UMF_triplet_map_x	 umfdl_triplet_map_x
  #define UMF_triplet_map_nox	 umfdl_triplet_map_nox
  #define UMF_triplet_nomap_x	 umfdl_triplet_nomap_x
  #define UMF_triplet_nomap_nox	 umfdl_triplet_nomap_nox
  #define UMF_2by2		 umfdl_2by2
  
  #define UMFPACK_col_to_triplet	 umfpack_dl_col_to_triplet
  #define UMFPACK_defaults	 umfpack_dl_defaults
  #define UMFPACK_free_numeric	 umfpack_dl_free_numeric
  #define UMFPACK_free_symbolic	 umfpack_dl_free_symbolic
  #define UMFPACK_get_lunz	 umfpack_dl_get_lunz
  #define UMFPACK_get_numeric	 umfpack_dl_get_numeric
  #define UMFPACK_get_symbolic	 umfpack_dl_get_symbolic
  #define UMFPACK_get_determinant	 umfpack_dl_get_determinant
  #define UMFPACK_numeric		 umfpack_dl_numeric
  #define UMFPACK_qsymbolic	 umfpack_dl_qsymbolic
  #define UMFPACK_report_control	 umfpack_dl_report_control
  #define UMFPACK_report_info	 umfpack_dl_report_info
  #define UMFPACK_report_matrix	 umfpack_dl_report_matrix
  #define UMFPACK_report_numeric	 umfpack_dl_report_numeric
  #define UMFPACK_report_perm	 umfpack_dl_report_perm
  #define UMFPACK_report_status	 umfpack_dl_report_status
  #define UMFPACK_report_symbolic	 umfpack_dl_report_symbolic
  #define UMFPACK_report_triplet	 umfpack_dl_report_triplet
  #define UMFPACK_report_vector	 umfpack_dl_report_vector
  #define UMFPACK_save_numeric	 umfpack_dl_save_numeric
  #define UMFPACK_save_symbolic	 umfpack_dl_save_symbolic
  #define UMFPACK_load_numeric	 umfpack_dl_load_numeric
  #define UMFPACK_load_symbolic	 umfpack_dl_load_symbolic
  #define UMFPACK_scale		 umfpack_dl_scale
  #define UMFPACK_solve		 umfpack_dl_solve
  #define UMFPACK_symbolic	 umfpack_dl_symbolic
  #define UMFPACK_transpose	 umfpack_dl_transpose
  #define UMFPACK_triplet_to_col	 umfpack_dl_triplet_to_col
  #define UMFPACK_wsolve		 umfpack_dl_wsolve
  
  /* for debugging only: */
  #define UMF_malloc_count	 umf_l_malloc_count
  #define UMF_debug		 umfdl_debug
  #define UMF_allocfail		 umfdl_allocfail
  #define UMF_gprob		 umfdl_gprob
  #define UMF_dump_dense		 umfdl_dump_dense
  #define UMF_dump_element	 umfdl_dump_element
  #define UMF_dump_rowcol		 umfdl_dump_rowcol
  #define UMF_dump_matrix		 umfdl_dump_matrix
  #define UMF_dump_current_front	 umfdl_dump_current_front
  #define UMF_dump_lu		 umfdl_dump_lu
  #define UMF_dump_memory		 umfdl_dump_memory
  #define UMF_dump_packed_memory	 umfdl_dump_packed_memory
  #define UMF_dump_col_matrix	 umfdl_dump_col_matrix
  #define UMF_dump_chain		 umfdl_dump_chain
  #define UMF_dump_start		 umfdl_dump_start
  #define UMF_dump_rowmerge	 umfdl_dump_rowmerge
  #define UMF_dump_diagonal_map	 umfdl_dump_diagonal_map
  
  #endif
  
  /* -------------------------------------------------------------------------- */
  /* Complex double precision, with int's as integers */
  /* -------------------------------------------------------------------------- */
  
  #ifdef ZINT
  
  #define UMF_analyze		 umf_i_analyze
  #define UMF_apply_order		 umf_i_apply_order
  #define UMF_assemble		 umfzi_assemble
  #define UMF_assemble_fixq	 umfzi_assemble_fixq
  #define UMF_blas3_update	 umfzi_blas3_update
  #define UMF_build_tuples	 umfzi_build_tuples
  #define UMF_build_tuples_usage	 umfzi_build_tuples_usage
  #define UMF_colamd		 umf_i_colamd
  #define UMF_colamd_set_defaults	 umf_i_colamd_set_defaults
  #define UMF_create_element	 umfzi_create_element
  #define UMF_extend_front	 umfzi_extend_front
  #define UMF_free		 umf_i_free
  #define UMF_fsize		 umf_i_fsize
  #define UMF_garbage_collection	 umfzi_garbage_collection
  #define UMF_get_memory		 umfzi_get_memory
  #define UMF_grow_front		 umfzi_grow_front
  #define UMF_init_front		 umfzi_init_front
  #define UMF_is_permutation	 umf_i_is_permutation
  #define UMF_kernel		 umfzi_kernel
  #define UMF_kernel_init		 umfzi_kernel_init
  #define UMF_kernel_init_usage	 umfzi_kernel_init_usage
  #define UMF_kernel_wrapup	 umfzi_kernel_wrapup
  #define UMF_local_search	 umfzi_local_search
  #define UMF_lsolve		 umfzi_lsolve
  #define UMF_ltsolve		 umfzi_ltsolve
  #define UMF_lhsolve		 umfzi_lhsolve
  #define UMF_malloc		 umf_i_malloc
  #define UMF_mem_alloc_element	 umfzi_mem_alloc_element
  #define UMF_mem_alloc_head_block umfzi_mem_alloc_head_block
  #define UMF_mem_alloc_tail_block umfzi_mem_alloc_tail_block
  #define UMF_mem_free_tail_block	 umfzi_mem_free_tail_block
  #define UMF_mem_init_memoryspace umfzi_mem_init_memoryspace
  #define UMF_realloc		 umf_i_realloc
  #define UMF_report_perm		 umf_i_report_perm
  #define UMF_report_vector	 umfzi_report_vector
  #define UMF_row_search		 umfzi_row_search
  #define UMF_scale		 umfzi_scale
  #define UMF_scale_column	 umfzi_scale_column
  #define UMF_set_stats		 umfzi_set_stats
  #define UMF_singletons		 umf_i_singletons
  #define UMF_solve		 umfzi_solve
  #define UMF_start_front		 umfzi_start_front
  #define UMF_store_lu		 umfzi_store_lu
  #define UMF_store_lu_drop	 umfzi_store_lu_drop
  #define UMF_symbolic_usage	 umfzi_symbolic_usage
  #define UMF_transpose		 umfzi_transpose
  #define UMF_tuple_lengths	 umfzi_tuple_lengths
  #define UMF_usolve		 umfzi_usolve
  #define UMF_utsolve		 umfzi_utsolve
  #define UMF_uhsolve		 umfzi_uhsolve
  #define UMF_valid_numeric	 umfzi_valid_numeric
  #define UMF_valid_symbolic	 umfzi_valid_symbolic
  #define UMF_triplet_map_x	 umfzi_triplet_map_x
  #define UMF_triplet_map_nox	 umfzi_triplet_map_nox
  #define UMF_triplet_nomap_x	 umfzi_triplet_nomap_x
  #define UMF_triplet_nomap_nox	 umfzi_triplet_nomap_nox
  #define UMF_2by2		 umfzi_2by2
  
  #define UMFPACK_col_to_triplet	 umfpack_zi_col_to_triplet
  #define UMFPACK_defaults	 umfpack_zi_defaults
  #define UMFPACK_free_numeric	 umfpack_zi_free_numeric
  #define UMFPACK_free_symbolic	 umfpack_zi_free_symbolic
  #define UMFPACK_get_lunz	 umfpack_zi_get_lunz
  #define UMFPACK_get_numeric	 umfpack_zi_get_numeric
  #define UMFPACK_get_symbolic	 umfpack_zi_get_symbolic
  #define UMFPACK_get_determinant	 umfpack_zi_get_determinant
  #define UMFPACK_numeric		 umfpack_zi_numeric
  #define UMFPACK_qsymbolic	 umfpack_zi_qsymbolic
  #define UMFPACK_report_control	 umfpack_zi_report_control
  #define UMFPACK_report_info	 umfpack_zi_report_info
  #define UMFPACK_report_matrix	 umfpack_zi_report_matrix
  #define UMFPACK_report_numeric	 umfpack_zi_report_numeric
  #define UMFPACK_report_perm	 umfpack_zi_report_perm
  #define UMFPACK_report_status	 umfpack_zi_report_status
  #define UMFPACK_report_symbolic	 umfpack_zi_report_symbolic
  #define UMFPACK_report_triplet	 umfpack_zi_report_triplet
  #define UMFPACK_report_vector	 umfpack_zi_report_vector
  #define UMFPACK_save_numeric	 umfpack_zi_save_numeric
  #define UMFPACK_save_symbolic	 umfpack_zi_save_symbolic
  #define UMFPACK_load_numeric	 umfpack_zi_load_numeric
  #define UMFPACK_load_symbolic	 umfpack_zi_load_symbolic
  #define UMFPACK_scale		 umfpack_zi_scale
  #define UMFPACK_solve		 umfpack_zi_solve
  #define UMFPACK_symbolic	 umfpack_zi_symbolic
  #define UMFPACK_transpose	 umfpack_zi_transpose
  #define UMFPACK_triplet_to_col	 umfpack_zi_triplet_to_col
  #define UMFPACK_wsolve		 umfpack_zi_wsolve
  
  /* for debugging only: */
  #define UMF_malloc_count	 umf_i_malloc_count
  #define UMF_debug		 umfzi_debug
  #define UMF_allocfail		 umfzi_allocfail
  #define UMF_gprob		 umfzi_gprob
  #define UMF_dump_dense		 umfzi_dump_dense
  #define UMF_dump_element	 umfzi_dump_element
  #define UMF_dump_rowcol		 umfzi_dump_rowcol
  #define UMF_dump_matrix		 umfzi_dump_matrix
  #define UMF_dump_current_front	 umfzi_dump_current_front
  #define UMF_dump_lu		 umfzi_dump_lu
  #define UMF_dump_memory		 umfzi_dump_memory
  #define UMF_dump_packed_memory	 umfzi_dump_packed_memory
  #define UMF_dump_col_matrix	 umfzi_dump_col_matrix
  #define UMF_dump_chain		 umfzi_dump_chain
  #define UMF_dump_start		 umfzi_dump_start
  #define UMF_dump_rowmerge	 umfzi_dump_rowmerge
  #define UMF_dump_diagonal_map	 umfzi_dump_diagonal_map
  
  #endif
  
  /* -------------------------------------------------------------------------- */
  /* Complex double precision, with UF_long's as integers */
  /* -------------------------------------------------------------------------- */
  
  #ifdef ZLONG
  
  #define UMF_analyze		 umf_l_analyze
  #define UMF_apply_order		 umf_l_apply_order
  #define UMF_assemble		 umfzl_assemble
  #define UMF_assemble_fixq	 umfzl_assemble_fixq
  #define UMF_blas3_update	 umfzl_blas3_update
  #define UMF_build_tuples	 umfzl_build_tuples
  #define UMF_build_tuples_usage	 umfzl_build_tuples_usage
  #define UMF_colamd		 umf_l_colamd
  #define UMF_colamd_set_defaults	 umf_l_colamd_set_defaults
  #define UMF_create_element	 umfzl_create_element
  #define UMF_extend_front	 umfzl_extend_front
  #define UMF_free		 umf_l_free
  #define UMF_fsize		 umf_l_fsize
  #define UMF_garbage_collection	 umfzl_garbage_collection
  #define UMF_get_memory		 umfzl_get_memory
  #define UMF_grow_front		 umfzl_grow_front
  #define UMF_init_front		 umfzl_init_front
  #define UMF_is_permutation	 umf_l_is_permutation
  #define UMF_kernel		 umfzl_kernel
  #define UMF_kernel_init		 umfzl_kernel_init
  #define UMF_kernel_init_usage	 umfzl_kernel_init_usage
  #define UMF_kernel_wrapup	 umfzl_kernel_wrapup
  #define UMF_local_search	 umfzl_local_search
  #define UMF_lsolve		 umfzl_lsolve
  #define UMF_ltsolve		 umfzl_ltsolve
  #define UMF_lhsolve		 umfzl_lhsolve
  #define UMF_malloc		 umf_l_malloc
  #define UMF_mem_alloc_element	 umfzl_mem_alloc_element
  #define UMF_mem_alloc_head_block umfzl_mem_alloc_head_block
  #define UMF_mem_alloc_tail_block umfzl_mem_alloc_tail_block
  #define UMF_mem_free_tail_block	 umfzl_mem_free_tail_block
  #define UMF_mem_init_memoryspace umfzl_mem_init_memoryspace
  #define UMF_realloc		 umf_l_realloc
  #define UMF_report_perm		 umf_l_report_perm
  #define UMF_report_vector	 umfzl_report_vector
  #define UMF_row_search		 umfzl_row_search
  #define UMF_scale		 umfzl_scale
  #define UMF_scale_column	 umfzl_scale_column
  #define UMF_set_stats		 umfzl_set_stats
  #define UMF_singletons		 umf_l_singletons
  #define UMF_solve		 umfzl_solve
  #define UMF_start_front		 umfzl_start_front
  #define UMF_store_lu		 umfzl_store_lu
  #define UMF_store_lu_drop	 umfzl_store_lu_drop
  #define UMF_symbolic_usage	 umfzl_symbolic_usage
  #define UMF_transpose		 umfzl_transpose
  #define UMF_tuple_lengths	 umfzl_tuple_lengths
  #define UMF_usolve		 umfzl_usolve
  #define UMF_utsolve		 umfzl_utsolve
  #define UMF_uhsolve		 umfzl_uhsolve
  #define UMF_valid_numeric	 umfzl_valid_numeric
  #define UMF_valid_symbolic	 umfzl_valid_symbolic
  #define UMF_triplet_map_x	 umfzl_triplet_map_x
  #define UMF_triplet_map_nox	 umfzl_triplet_map_nox
  #define UMF_triplet_nomap_x	 umfzl_triplet_nomap_x
  #define UMF_triplet_nomap_nox	 umfzl_triplet_nomap_nox
  #define UMF_2by2		 umfzl_2by2
  
  #define UMFPACK_col_to_triplet	 umfpack_zl_col_to_triplet
  #define UMFPACK_defaults	 umfpack_zl_defaults
  #define UMFPACK_free_numeric	 umfpack_zl_free_numeric
  #define UMFPACK_free_symbolic	 umfpack_zl_free_symbolic
  #define UMFPACK_get_lunz	 umfpack_zl_get_lunz
  #define UMFPACK_get_numeric	 umfpack_zl_get_numeric
  #define UMFPACK_get_symbolic	 umfpack_zl_get_symbolic
  #define UMFPACK_get_determinant	 umfpack_zl_get_determinant
  #define UMFPACK_numeric		 umfpack_zl_numeric
  #define UMFPACK_qsymbolic	 umfpack_zl_qsymbolic
  #define UMFPACK_report_control	 umfpack_zl_report_control
  #define UMFPACK_report_info	 umfpack_zl_report_info
  #define UMFPACK_report_matrix	 umfpack_zl_report_matrix
  #define UMFPACK_report_numeric	 umfpack_zl_report_numeric
  #define UMFPACK_report_perm	 umfpack_zl_report_perm
  #define UMFPACK_report_status	 umfpack_zl_report_status
  #define UMFPACK_report_symbolic	 umfpack_zl_report_symbolic
  #define UMFPACK_report_triplet	 umfpack_zl_report_triplet
  #define UMFPACK_report_vector	 umfpack_zl_report_vector
  #define UMFPACK_save_numeric	 umfpack_zl_save_numeric
  #define UMFPACK_save_symbolic	 umfpack_zl_save_symbolic
  #define UMFPACK_load_numeric	 umfpack_zl_load_numeric
  #define UMFPACK_load_symbolic	 umfpack_zl_load_symbolic
  #define UMFPACK_scale		 umfpack_zl_scale
  #define UMFPACK_solve		 umfpack_zl_solve
  #define UMFPACK_symbolic	 umfpack_zl_symbolic
  #define UMFPACK_transpose	 umfpack_zl_transpose
  #define UMFPACK_triplet_to_col	 umfpack_zl_triplet_to_col
  #define UMFPACK_wsolve		 umfpack_zl_wsolve
  
  /* for debugging only: */
  #define UMF_malloc_count	 umf_l_malloc_count
  #define UMF_debug		 umfzl_debug
  #define UMF_allocfail		 umfzl_allocfail
  #define UMF_gprob		 umfzl_gprob
  #define UMF_dump_dense		 umfzl_dump_dense
  #define UMF_dump_element	 umfzl_dump_element
  #define UMF_dump_rowcol		 umfzl_dump_rowcol
  #define UMF_dump_matrix		 umfzl_dump_matrix
  #define UMF_dump_current_front	 umfzl_dump_current_front
  #define UMF_dump_lu		 umfzl_dump_lu
  #define UMF_dump_memory		 umfzl_dump_memory
  #define UMF_dump_packed_memory	 umfzl_dump_packed_memory
  #define UMF_dump_col_matrix	 umfzl_dump_col_matrix
  #define UMF_dump_chain		 umfzl_dump_chain
  #define UMF_dump_start		 umfzl_dump_start
  #define UMF_dump_rowmerge	 umfzl_dump_rowmerge
  #define UMF_dump_diagonal_map	 umfzl_dump_diagonal_map
  
  #endif