mirror of
https://github.com/amd/blis.git
synced 2026-06-29 18:57:23 +00:00
445 lines
11 KiB
C
445 lines
11 KiB
C
/****************************************************************
|
|
Copyright 1990 - 1997 by AT&T, Lucent Technologies and Bellcore.
|
|
|
|
Permission to use, copy, modify, and distribute this software
|
|
and its documentation for any purpose and without fee is hereby
|
|
granted, provided that the above copyright notice appear in all
|
|
copies and that both that the copyright notice and this
|
|
permission notice and warranty disclaimer appear in supporting
|
|
documentation, and that the names of AT&T, Bell Laboratories,
|
|
Lucent or Bellcore or any of their entities not be used in
|
|
advertising or publicity pertaining to distribution of the
|
|
software without specific, written prior permission.
|
|
|
|
AT&T, Lucent and Bellcore disclaim all warranties with regard to
|
|
this software, including all implied warranties of
|
|
merchantability and fitness. In no event shall AT&T, Lucent or
|
|
Bellcore be liable for any special, indirect or consequential
|
|
damages or any damages whatsoever resulting from loss of use,
|
|
data or profits, whether in an action of contract, negligence or
|
|
other tortious action, arising out of or in connection with the
|
|
use or performance of this software.
|
|
****************************************************************/
|
|
|
|
/* include/f2c.h. Generated from f2c.h.in by configure. */
|
|
/* f2c.h -- Standard Fortran to C header file */
|
|
|
|
/** barf [ba:rf] 2. "He suggested using FORTRAN, and everybody barfed."
|
|
|
|
- From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
|
|
|
|
#ifndef F2C_INCLUDE
|
|
#define F2C_INCLUDE
|
|
|
|
#include <math.h>
|
|
#include <string.h>
|
|
#include <f2c_types.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#ifdef INTEGER_STAR_8 /* Adjust for integer*8. */
|
|
#define qbit_clear(a,b) ((a) & ~((ulongint)1 << (b)))
|
|
#define qbit_set(a,b) ((a) | ((ulongint)1 << (b)))
|
|
#endif
|
|
|
|
#define TRUE_ (1)
|
|
#define FALSE_ (0)
|
|
|
|
/* Extern is for use with -E */
|
|
#ifndef Extern
|
|
#define Extern extern
|
|
#endif
|
|
|
|
/* I/O stuff */
|
|
|
|
/*external read, write*/
|
|
typedef struct
|
|
{ flag cierr;
|
|
ftnint ciunit;
|
|
flag ciend;
|
|
char *cifmt;
|
|
ftnint cirec;
|
|
} cilist;
|
|
|
|
/*internal read, write*/
|
|
typedef struct
|
|
{ flag icierr;
|
|
char *iciunit;
|
|
flag iciend;
|
|
char *icifmt;
|
|
ftnint icirlen;
|
|
ftnint icirnum;
|
|
} icilist;
|
|
|
|
/*open*/
|
|
typedef struct
|
|
{ flag oerr;
|
|
ftnint ounit;
|
|
char *ofnm;
|
|
ftnlen ofnmlen;
|
|
char *osta;
|
|
char *oacc;
|
|
char *ofm;
|
|
ftnint orl;
|
|
char *oblnk;
|
|
} olist;
|
|
|
|
/*close*/
|
|
typedef struct
|
|
{ flag cerr;
|
|
ftnint cunit;
|
|
char *csta;
|
|
} cllist;
|
|
|
|
/*rewind, backspace, endfile*/
|
|
typedef struct
|
|
{ flag aerr;
|
|
ftnint aunit;
|
|
} alist;
|
|
|
|
/* inquire */
|
|
typedef struct
|
|
{ flag inerr;
|
|
ftnint inunit;
|
|
char *infile;
|
|
ftnlen infilen;
|
|
ftnint *inex; /*parameters in standard's order*/
|
|
ftnint *inopen;
|
|
ftnint *innum;
|
|
ftnint *innamed;
|
|
char *inname;
|
|
ftnlen innamlen;
|
|
char *inacc;
|
|
ftnlen inacclen;
|
|
char *inseq;
|
|
ftnlen inseqlen;
|
|
char *indir;
|
|
ftnlen indirlen;
|
|
char *infmt;
|
|
ftnlen infmtlen;
|
|
char *inform;
|
|
ftnint informlen;
|
|
char *inunf;
|
|
ftnlen inunflen;
|
|
ftnint *inrecl;
|
|
ftnint *innrec;
|
|
char *inblank;
|
|
ftnlen inblanklen;
|
|
} inlist;
|
|
|
|
union Multitype { /* for multiple entry points */
|
|
integer1 g;
|
|
shortint h;
|
|
integer i;
|
|
/* longint j; */
|
|
real r;
|
|
doublereal d;
|
|
complex c;
|
|
doublecomplex z;
|
|
};
|
|
|
|
typedef union Multitype Multitype;
|
|
|
|
struct Vardesc { /* for Namelist */
|
|
char *name;
|
|
char *addr;
|
|
ftnlen *dims;
|
|
int type;
|
|
};
|
|
typedef struct Vardesc Vardesc;
|
|
|
|
struct Namelist {
|
|
char *name;
|
|
Vardesc **vars;
|
|
int nvars;
|
|
};
|
|
typedef struct Namelist Namelist;
|
|
|
|
#ifndef _MSC_VER
|
|
#define min(a,b) ((a) <= (b) ? (a) : (b))
|
|
#define max(a,b) ((a) >= (b) ? (a) : (b))
|
|
#endif
|
|
#define abs(x) ((x) >= 0 ? (x) : -(x))
|
|
#define dabs(x) (doublereal)abs(x)
|
|
#define dmin(a,b) (doublereal)min(a,b)
|
|
#define dmax(a,b) (doublereal)max(a,b)
|
|
#define bit_test(a,b) ((a) >> (b) & 1)
|
|
#define bit_clear(a,b) ((a) & ~((uinteger)1 << (b)))
|
|
#define bit_set(a,b) ((a) | ((uinteger)1 << (b)))
|
|
|
|
/* undef any lower-case symbols that your C compiler predefines, e.g.: */
|
|
|
|
#ifndef Skip_f2c_Undefs
|
|
/* #undef cray */
|
|
/* #undef gcos */
|
|
/* #undef mc68010 */
|
|
/* #undef mc68020 */
|
|
/* #undef mips */
|
|
/* #undef pdp11 */
|
|
/* #undef sgi */
|
|
/* #undef sparc */
|
|
/* #undef sun */
|
|
/* #undef sun2 */
|
|
/* #undef sun3 */
|
|
/* #undef sun4 */
|
|
/* #undef u370 */
|
|
/* #undef u3b */
|
|
/* #undef u3b2 */
|
|
/* #undef u3b5 */
|
|
/* #undef unix */
|
|
/* #undef vax */
|
|
#endif
|
|
|
|
void libf2c_init(int argc, char **argv);
|
|
void libf2c_close();
|
|
|
|
/*************************************************************
|
|
* LIBF77
|
|
*/
|
|
|
|
/*
|
|
* Private functions and variables in libF77
|
|
*/
|
|
extern int xargc;
|
|
extern char **xargv;
|
|
extern doublereal _0;
|
|
|
|
double f__cabs(double, double);
|
|
char *F77_aloc(integer Len, const char *whence);
|
|
void sig_die(const char*, int);
|
|
void _uninit_f2c(void *x, int type, long len);
|
|
|
|
/*
|
|
* Public functions in libF77
|
|
*/
|
|
|
|
int abort_(void);
|
|
|
|
void c_cos(complex *r, complex *z);
|
|
void c_div(complex *c, complex *a, complex *b);
|
|
void c_exp(complex *r, complex *z);
|
|
void c_log(complex *r, complex *z);
|
|
void c_sin(complex *r, complex *z);
|
|
void c_sqrt(complex *r, complex *z);
|
|
|
|
double dtime_(float *tarray);
|
|
|
|
int ef1asc_(ftnint *a, ftnlen *la, ftnint *b, ftnlen *lb);
|
|
integer ef1cmc_(ftnint *a, ftnlen *la, ftnint *b, ftnlen *lb);
|
|
|
|
real etime_(real *tarray);
|
|
|
|
int getarg_(ftnint *n, char *s, ftnlen ls);
|
|
int getenv_(char *fname, char *value, ftnlen flen, ftnlen vlen);
|
|
|
|
shortint h_indx(char *a, char *b, ftnlen la, ftnlen lb);
|
|
|
|
integer i_indx(char *a, char *b, ftnlen la, ftnlen lb);
|
|
|
|
logical l_ge(char *a, char *b, ftnlen la, ftnlen lb);
|
|
logical l_gt(char *a, char *b, ftnlen la, ftnlen lb);
|
|
logical l_le(char *a, char *b, ftnlen la, ftnlen lb);
|
|
logical l_lt(char *a, char *b, ftnlen la, ftnlen lb);
|
|
|
|
integer lbit_bits(integer a, integer b, integer len);
|
|
integer lbit_shift(integer a, integer b);
|
|
integer lbit_cshift(integer a, integer b, integer len);
|
|
|
|
void pow_ci(complex *p, complex *a, integer *b);
|
|
double pow_dd(doublereal *ap, doublereal *bp);
|
|
double pow_di(doublereal *ap, integer *bp);
|
|
shortint pow_hh(shortint *ap, shortint *bp);
|
|
integer pow_ii(integer *ap, integer *bp);
|
|
#ifdef INTEGER_STAR_8
|
|
longint pow_qq(longint *ap, longint *bp);
|
|
#endif
|
|
double pow_ri(real *ap, integer *bp);
|
|
void pow_zi(doublecomplex*, doublecomplex*, integer*);
|
|
void pow_zz(doublecomplex *r, doublecomplex *a, doublecomplex *b);
|
|
|
|
#ifdef INTEGER_STAR_8
|
|
longint qbit_bits(longint a, integer b, integer len);
|
|
longint qbit_cshift(longint a, integer b, integer len);
|
|
longint qbit_shift(longint a, integer b);
|
|
#endif
|
|
|
|
double r_abs(real *x);
|
|
double r_acos(real *x);
|
|
double r_asin(real *x);
|
|
double r_atan(real *x);
|
|
double r_atn2(real *x, real *y);
|
|
void r_cnjg(complex *r, complex *z);
|
|
double r_cos(real *x);
|
|
double r_cosh(real *x);
|
|
double r_dim(real *a, real *b);
|
|
double r_exp(real *x);
|
|
double r_imag(complex *z);
|
|
double r_int(real *x);
|
|
double r_lg10(real *x);
|
|
double r_log(real *x);
|
|
double r_mod(real *x, real *y);
|
|
double r_nint(real *x);
|
|
double r_sign(real *a, real *b);
|
|
double r_sin(real *x);
|
|
double r_sinh(real *x);
|
|
double r_sqrt(real *x);
|
|
double r_tan(real *x);
|
|
double r_tanh(real *x);
|
|
|
|
int s_cat(char *lp, char *rpp[], ftnint rnp[], ftnint *np, ftnlen ll);
|
|
integer s_cmp(const char *a0, const char *b0, ftnlen la, ftnlen lb);
|
|
int s_paus(char *s, ftnlen n);
|
|
integer s_rnge(char *varn, ftnint offset, char *procn, ftnint line);
|
|
int s_stop(char *s, ftnlen n);
|
|
|
|
ftnint signal_(integer *sigp, void *proc);
|
|
integer system_(register char *s, ftnlen n);
|
|
|
|
void z_div(doublecomplex*, doublecomplex*, doublecomplex*);
|
|
void z_cos(doublecomplex *r, doublecomplex *z);
|
|
void z_exp(doublecomplex *r, doublecomplex *z);
|
|
void z_log(doublecomplex *r, doublecomplex *z);
|
|
void z_sin(doublecomplex *r, doublecomplex *z);
|
|
void z_sqrt(doublecomplex *r, doublecomplex *z);
|
|
|
|
/*
|
|
#ifndef F2C_NO_INLINE_H
|
|
# if defined(__GNUC__)
|
|
# include <f2c_inline.h>
|
|
# endif
|
|
#endif
|
|
*/
|
|
|
|
#if !defined(F2C_INLINE_H)
|
|
double c_abs(const complex *z);
|
|
double d_abs(const doublereal *x);
|
|
double d_acos(const doublereal *x);
|
|
double d_asin(const doublereal *x);
|
|
double d_atan(const doublereal *x);
|
|
double d_atn2(const doublereal *x, const doublereal *y);
|
|
void d_cnjg(doublecomplex *r, const doublecomplex *z);
|
|
double d_cos(const doublereal *x);
|
|
double d_cosh(const doublereal *x);
|
|
double d_dim(const doublereal *a, const doublereal *b);
|
|
double d_exp(const doublereal *x);
|
|
double d_imag(const doublecomplex *z);
|
|
double d_int(const doublereal *x);
|
|
double d_lg10(const doublereal *x);
|
|
double d_log(const doublereal *x);
|
|
double d_mod(const doublereal *x, const doublereal *y);
|
|
double d_nint(const doublereal *x);
|
|
double d_prod(const real *x, const real *y);
|
|
double d_sign(const doublereal *a, const doublereal *b);
|
|
double d_sin(const doublereal *x);
|
|
double d_sinh(const doublereal *x);
|
|
double d_sqrt(const doublereal *x);
|
|
double d_tan(const doublereal *x);
|
|
double d_tanh(const doublereal *x);
|
|
double derf_(const doublereal *x);
|
|
double derfc_(const doublereal *x);
|
|
double erf_(const real *x);
|
|
double erfc_(const real *x);
|
|
shortint h_abs(const shortint *x);
|
|
shortint h_dim(const shortint *a, const shortint *b);
|
|
shortint h_dnnt(const doublereal *x);
|
|
shortint h_len(const char *s, ftnlen n);
|
|
shortint h_mod(const short *a, const short *b);
|
|
shortint h_nint(const real *x);
|
|
shortint h_sign(const shortint *a, const shortint *b);
|
|
shortlogical hl_ge(const char *a, const char *b, ftnlen la, ftnlen lb);
|
|
shortlogical hl_gt(const char *a, const char *b, ftnlen la, ftnlen lb);
|
|
shortlogical hl_le(const char *a, const char *b, ftnlen la, ftnlen lb);
|
|
shortlogical hl_lt(const char *a, const char *b, ftnlen la, ftnlen lb);
|
|
integer i_abs(const integer *x);
|
|
integer i_dceiling(const doublereal *x);
|
|
integer i_dim(const integer *a, const integer *b);
|
|
integer i_dnnt(const doublereal *x);
|
|
integer i_len(const char *s, ftnlen n);
|
|
integer i_len_trim(const char *s, ftnlen n);
|
|
integer i_mod(const integer *a, const integer *b);
|
|
integer i_nint(const real *x);
|
|
integer i_sign(const integer *a, const integer *b);
|
|
integer i_sceiling(const real *x);
|
|
ftnint iargc_(void);
|
|
int s_copy(char *a, const char *b, ftnlen la, ftnlen lb);
|
|
double z_abs(const doublecomplex *z);
|
|
#endif /* !F2C_INLINE_H */
|
|
|
|
/*************************************************************
|
|
* LIBI77
|
|
*
|
|
* Public functions
|
|
*/
|
|
|
|
int c_dfe(cilist *a);
|
|
int c_due(cilist *a);
|
|
int c_sfe(cilist *a);
|
|
int c_sue(cilist *a);
|
|
|
|
integer e_rdfe(void);
|
|
integer e_rdue(void);
|
|
integer e_rsfe(void);
|
|
integer e_rsfi(void);
|
|
integer e_rsle(void);
|
|
integer e_rsli(void);
|
|
integer e_rsue(void);
|
|
integer e_wdfe(void);
|
|
integer e_wdue(void);
|
|
integer e_wsfi(void);
|
|
integer e_wsfe(void);
|
|
integer e_wsle(void);
|
|
integer e_wsli(void);
|
|
integer e_wsue(void);
|
|
|
|
void exit_(integer *rc);
|
|
|
|
integer f_back(alist *a);
|
|
integer f_clos(cllist *a);
|
|
integer f_end(alist *a);
|
|
void f_exit(void);
|
|
integer f_inqu(inlist *a);
|
|
integer f_open(olist *a);
|
|
integer f_rew(alist *a);
|
|
int flush_(void);
|
|
|
|
integer ftell_(integer *Unit);
|
|
int fseek_(integer *Unit, integer *offset, integer *whence);
|
|
#ifdef INTEGER_STAR_8
|
|
longint ftell64_(integer *Unit);
|
|
int fseek64_(integer *Unit, longint *offset, integer *whence);
|
|
#endif
|
|
|
|
integer s_rdfe(cilist *a);
|
|
integer s_rdue(cilist *a);
|
|
integer s_rsfi(icilist *a);
|
|
integer s_rsle(cilist *a);
|
|
integer s_rsli(icilist *a);
|
|
integer s_rsne(cilist *a);
|
|
integer s_rsni(icilist *a);
|
|
integer s_rsue(cilist *a);
|
|
integer s_wdfe(cilist *a);
|
|
integer s_wdue(cilist *a);
|
|
integer s_wsfe(cilist *a);
|
|
integer s_wsfi(icilist *a);
|
|
integer s_wsle(cilist *a);
|
|
integer s_wsli(icilist *a);
|
|
integer s_wsne(cilist *a);
|
|
integer s_wsni(icilist *a);
|
|
integer s_wsue(cilist *a);
|
|
|
|
real s_epsilon_( real* x );
|
|
double d_epsilon_( doublereal* x );
|
|
|
|
/*
|
|
* Private functions in the F2C library
|
|
*/
|
|
extern const ftnlen f__typesize[];
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif
|