/* err/gsl_errno.h

 * 

 * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or (at

 * your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 */

#ifndef __GSL_ERRNO_H__

#define __GSL_ERRNO_H__

#include <stdio.h>

#include <errno.h>

#include <gsl/gsl_types.h>

#undef __BEGIN_DECLS

#undef __END_DECLS

#ifdef __cplusplus

# define __BEGIN_DECLS extern "C" {

# define __END_DECLS }

#else

# define __BEGIN_DECLS /* empty */

# define __END_DECLS /* empty */

#endif

__BEGIN_DECLS

enum { 

  GSL_SUCCESS  = 0, 

  GSL_FAILURE  = -1,

  GSL_CONTINUE = -2,  /* iteration has not converged */

  GSL_EDOM     = 1,   /* input domain error, e.g sqrt(-1) */

  GSL_ERANGE   = 2,   /* output range error, e.g. exp(1e100) */

  GSL_EFAULT   = 3,   /* invalid pointer */

  GSL_EINVAL   = 4,   /* invalid argument supplied by user */

  GSL_EFAILED  = 5,   /* generic failure */

  GSL_EFACTOR  = 6,   /* factorization failed */

  GSL_ESANITY  = 7,   /* sanity check failed - shouldn't happen */

  GSL_ENOMEM   = 8,   /* malloc failed */

  GSL_EBADFUNC = 9,   /* problem with user-supplied function */

  GSL_ERUNAWAY = 10,  /* iterative process is out of control */

  GSL_EMAXITER = 11,  /* exceeded max number of iterations */

  GSL_EZERODIV = 12,  /* tried to divide by zero */

  GSL_EBADTOL  = 13,  /* user specified an invalid tolerance */

  GSL_ETOL     = 14,  /* failed to reach the specified tolerance */

  GSL_EUNDRFLW = 15,  /* underflow */

  GSL_EOVRFLW  = 16,  /* overflow  */

  GSL_ELOSS    = 17,  /* loss of accuracy */

  GSL_EROUND   = 18,  /* failed because of roundoff error */

  GSL_EBADLEN  = 19,  /* matrix, vector lengths are not conformant */

  GSL_ENOTSQR  = 20,  /* matrix not square */

  GSL_ESING    = 21,  /* apparent singularity detected */

  GSL_EDIVERGE = 22,  /* integral or series is divergent */

  GSL_EUNSUP   = 23,  /* requested feature is not supported by the hardware */

  GSL_EUNIMPL  = 24,  /* requested feature not (yet) implemented */

  GSL_ECACHE   = 25,  /* cache limit exceeded */

  GSL_ETABLE   = 26,  /* table limit exceeded */

  GSL_ENOPROG  = 27,  /* iteration is not making progress towards solution */

  GSL_ENOPROGJ = 28,  /* jacobian evaluations are not improving the solution */

  GSL_ETOLF    = 29,  /* cannot reach the specified tolerance in F */

  GSL_ETOLX    = 30,  /* cannot reach the specified tolerance in X */

  GSL_ETOLG    = 31,  /* cannot reach the specified tolerance in gradient */

  GSL_EOF      = 32   /* end of file */

} ;

void gsl_error (const char * reason, const char * file, int line,

                int gsl_errno);

void gsl_stream_printf (const char *label, const char *file,

                        int line, const char *reason);

const char * gsl_strerror (const int gsl_errno);

typedef void gsl_error_handler_t (const char * reason, const char * file,

                                  int line, int gsl_errno);

typedef void gsl_stream_handler_t (const char * label, const char * file,

                                   int line, const char * reason);

gsl_error_handler_t * 

gsl_set_error_handler (gsl_error_handler_t * new_handler);

gsl_error_handler_t *

gsl_set_error_handler_off (void);

gsl_stream_handler_t * 

gsl_set_stream_handler (gsl_stream_handler_t * new_handler);

FILE * gsl_set_stream (FILE * new_stream);

/* GSL_ERROR: call the error handler, and return the error code */

#define GSL_ERROR(reason, gsl_errno) \

       do { \

       gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \

       return gsl_errno ; \

       } while (0)

/* GSL_ERROR_VAL: call the error handler, and return the given value */

#define GSL_ERROR_VAL(reason, gsl_errno, value) \

       do { \

       gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \

       return value ; \

       } while (0)

/* GSL_ERROR_VOID: call the error handler, and then return

   (for void functions which still need to generate an error) */

#define GSL_ERROR_VOID(reason, gsl_errno) \

       do { \

       gsl_error (reason, __FILE__, __LINE__, gsl_errno) ; \

       return ; \

       } while (0)

/* GSL_ERROR_NULL suitable for out-of-memory conditions */

#define GSL_ERROR_NULL(reason, gsl_errno) GSL_ERROR_VAL(reason, gsl_errno, 0)

/* Sometimes you have several status results returned from

 * function calls and you want to combine them in some sensible

 * way. You cannot produce a "total" status condition, but you can

 * pick one from a set of conditions based on an implied hierarchy.

 *

 * In other words:

 *    you have: status_a, status_b, ...

 *    you want: status = (status_a if it is bad, or status_b if it is bad,...)

 *

 * In this example you consider status_a to be more important and

 * it is checked first, followed by the others in the order specified.

 *

 * Here are some dumb macros to do this.

 */

#define GSL_ERROR_SELECT_2(a,b)       ((a) != GSL_SUCCESS ? (a) : ((b) != GSL_SUCCESS ? (b) : GSL_SUCCESS))

#define GSL_ERROR_SELECT_3(a,b,c)     ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_2(b,c))

#define GSL_ERROR_SELECT_4(a,b,c,d)   ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_3(b,c,d))

#define GSL_ERROR_SELECT_5(a,b,c,d,e) ((a) != GSL_SUCCESS ? (a) : GSL_ERROR_SELECT_4(b,c,d,e))

#define GSL_STATUS_UPDATE(sp, s) do { if ((s) != GSL_SUCCESS) *(sp) = (s);} while(0)

__END_DECLS

#endif /* __GSL_ERRNO_H__ */