self@BAYES.ARC.NASA.GOV (Matthew Self) (10/12/88)
gcc version 1.29 (with corrected patch of 11 Oct 88) gets fatal
error (when debugging only) on a Sun 3 running 4.0
Specifics:
gcc -v => gcc version 1.29
gcc -c -g => gcc: Program cc1 got fatal signal 11.
(note that gcc -c and gcc -c -O produce working code.)
config.h => config-sun4.h
tm.h => tm-sun3.h
md => m68k.md
aux-output.c => output-m68k.c
P.S. I tried installing gdb 2.8 today (same machine) with no luck.
I made patches to core.c replacing references to c_fpstatus and
c_fparegs with c_fpu.f_pstatus and c_fpu.f_fparegs to come into line
with the new <sys/core.h>. Compilation was successful, but gdb dumps
core when it tries to load symbol table info. Has anyone made this
work under 4.0 yet?
=========================exmaple code=============================
extern struct _iobuf {
int _cnt;
unsigned char *_ptr;
unsigned char *_base;
int _bufsiz;
short _flag;
char _file;
} _iob[];
extern struct _iobuf *fopen();
extern struct _iobuf *fdopen();
extern struct _iobuf *freopen();
extern struct _iobuf *popen();
extern struct _iobuf *tmpfile();
extern long ftell();
extern char *fgets();
extern char *gets();
extern char *ctermid();
extern char *cuserid();
extern char *tempnam();
extern char *tmpnam();
enum fp_direction_type
{
fp_nearest = 0,
fp_tozero = 1,
fp_negative = 2,
fp_positive = 3
} ;
enum fp_precision_type
{
fp_extended = 0,
fp_single = 1,
fp_double = 2,
fp_precision_3 = 3
} ;
enum fp_exception_type
{
fp_inexact = 0,
fp_division = 1,
fp_underflow = 2,
fp_overflow = 3,
fp_invalid = 4
} ;
enum fp_class_type
{
fp_zero = 0,
fp_subnormal = 1,
fp_normal = 2,
fp_infinity = 3,
fp_quiet = 4,
fp_signaling = 5
} ;
typedef float single ;
typedef unsigned extended[3] ;
typedef unsigned fp_exception_field_type ;
typedef int sigfpe_code_type ;
typedef void (* sigfpe_handler_type)() ;
extern enum fp_direction_type fp_direction ;
extern enum fp_precision_type fp_precision ;
extern sigfpe_handler_type ieee_handlers [5 ] ;
extern fp_exception_field_type fp_accrued_exceptions ;
extern sigfpe_handler_type sigfpe( ) ;
typedef char decimal_string[512 ] ;
typedef struct
{
enum fp_class_type fpclass ;
int sign ;
int exponent ;
decimal_string ds ;
int more ;
int ndigits ;
}
decimal_record ;
enum decimal_form
{
fixed_form,
floating_form
} ;
typedef struct
{
enum fp_direction_type rd ;
enum decimal_form df ;
int ndigits ;
}
decimal_mode ;
enum decimal_string_form
{
invalid_form,
whitespace_form,
fixed_int_form,
fixed_intdot_form,
fixed_dotfrac_form,
fixed_intdotfrac_form,
floating_int_form,
floating_intdot_form,
floating_dotfrac_form,
floating_intdotfrac_form,
inf_form,
infinity_form,
nan_form,
nanstring_form
} ;
extern void single_to_decimal ( ) ;
extern void double_to_decimal ( ) ;
extern void extended_to_decimal ( ) ;
extern void decimal_to_single ( ) ;
extern void decimal_to_double ( ) ;
extern void decimal_to_extended ( ) ;
extern char *econvert( ) ;
extern char *fconvert( ) ;
extern char *gconvert( ) ;
extern char *seconvert( ) ;
extern char *sfconvert( ) ;
extern char *sgconvert( ) ;
extern void string_to_decimal( ) ;
extern void file_to_decimal( ) ;
extern void func_to_decimal( ) ;
extern double atof();
extern int errno;
extern double strtod ();
extern int finite();
extern double fabs(), floor(), ceil(), rint();
extern double hypot();
extern double copysign();
extern double sqrt();
extern double modf(), frexp();
extern double asinh(), acosh(), atanh();
extern double erf(), erfc();
extern double exp(), expm1(), log(), log10(), log1p(), pow();
extern double lgamma();
extern double j0(), j1(), jn(), y0(), y1(), yn();
extern double sin(), cos(), tan(), asin(), acos(), atan(), atan2();
extern double sinh(), cosh(), tanh();
extern double cbrt();
enum fp_pi_type {
fp_pi_infinite = 0,
fp_pi_66 = 1,
fp_pi_53 = 2
} ;
extern enum fp_pi_type fp_pi ;
extern enum fp_class_type fp_class() ;
extern int ilogb(), irint(), signbit() ;
extern int isinf(), isnan(), isnormal(), issubnormal(), iszero() ;
extern double nextafter(), remainder() ;
extern double logb(), significand(), scalb(), scalbn();
extern double min_subnormal(), max_subnormal();
extern double min_normal(), max_normal();
extern double infinity(), quiet_nan(), signaling_nan();
extern double log2(), exp10(), exp2(), aint(), anint() ;
extern int nint() ;
extern void sincos();
extern int ieee_flags ();
extern int ieee_handler ();
extern int ir_finite_();
extern int r_fabs_(), r_floor_(), r_ceil_(), r_rint_();
extern int r_hypot_();
extern int r_copysign_();
extern int r_sqrt_();
extern int r_asinh_(), r_acosh_(), r_atanh_();
extern int r_erf_(), r_erfc_();
extern int r_exp_(), r_expm1_(), r_log_(), r_log10_(), r_log1p_();
extern int r_pow_();
extern int r_lgamma_();
extern int r_j0_(), r_j1_(), r_jn_(), r_y0_(), r_y1_(), r_yn_();
extern int r_sin_(), r_cos_(), r_tan_(), r_asin_(), r_acos_();
extern int r_atan_(), r_atan2_();
extern int r_sinh_(), r_cosh_(), r_tanh_();
extern int r_cbrt_();
extern int ir_ilogb_(), ir_irint_(), ir_signbit_() ;
extern int ir_isinf_(), ir_isnan_(),
ir_issubnormal_(), ir_isnormal_(), ir_iszero_() ;
extern enum fp_class_type ir_fp_class_();
extern int r_nextafter_(), r_remainder_() ;
extern int r_log2_(), r_exp10_(), r_exp2_(), r_aint_(), r_anint_() ;
extern int ir_nint_() ;
extern int r_fmod_();
extern int r_logb_(), r_significand_(), r_scalb_(), r_scalbn_();
extern int r_min_subnormal_(), r_max_subnormal_();
extern int r_min_normal_(), r_max_normal_();
extern int r_infinity_(), r_quiet_nan_(), r_signaling_nan_();
extern void r_sincos_();
struct exception {
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern int signgam;
extern double fmod();
extern int matherr();
extern double cabs();
extern double drem();
extern double gamma();
extern double ldexp();
int output= 1;
int start= 0;
int N= 2,M= 3,T= 10,L= 1;
extern int rand();
extern void srand();
extern int atoi();
void random_states(a,pi,i,N,T)
int N,T;
float a[][N],pi[];
int i[];
{
int t;
i[0]= random_selection(pi,N);
for(t= 1;t<T;t++)
i[t]= random_selection(a[i[t-1]],N);
}
void random_output(b,i,o,M,T)
int M,T;
float b[][M];
int i[],o[];
{
int t;
for(t= 0;t<T;t++)
o[t]= random_selection(b[i[t]],M);
}
float random_float()
{
return((float)rand()/(float)2147483647 );
}
int random_selection(a,N)
int N;
float a[];
{
int i;
float x;
x= random_float();
for(i= 0;i<N;i++){
x-= a[i];
if(x<0.0)
return(i);
}
printf("rounding error?\n");
return(N-1);
}
void random_distribution(a,N)
int N;
float a[];
{
int i;
float sum,factor;
sum= 0.0;
for(i= 0;i<N;i++){
float temp;
temp= random_float();
a[i]= temp;
sum+= temp;
}
factor= 1.0/sum;
for(i= 0;i<N;i++)
a[i]*= factor;
}
void random_transition_matrix(a,N)
int N;
float a[][N];
{
int i;
for(i= 0;i<N;i++)
random_distribution(a[i],N);
}
void random_initial_probabilities(pi,N)
int N;
float pi[];
{
random_distribution(pi,N);
}
void random_output_matrix(b,N,M)
int N,M;
float b[][M];
{
int i;
for(i= 0;i<N;i++)
random_distribution(b[i],M);
}
float forward_backward(a,b,pi,a_bar,b_bar,pi_bar,o,N,M,T)
int N,M,T;
float a[][N],b[][M],pi[];
float a_bar[][N],b_bar[][M],pi_bar[];
int o[];
{
float alpha[T][N],beta[T][N],gamma_T_minus_1[N];
float sigma[T],eta[N];
int t,i;
float log_likelihood;
log_likelihood= 0.0;
for(t= 0;t<T;t++){
int j;
float factor;
float alpha_sum= 0.0;
for(j= 0;j<N;j++){
float temp;
if(t==0)
temp= pi[j]*b[j][o[0]];
else{
int i;
float sum= 0.0;
for(i= 0;i<N;i++)
sum+= alpha[t-1][i]*a[i][j];
temp= sum*b[j][o[t]];
}
alpha[t][j]= temp;
alpha_sum+= temp;
}
factor= 1.0/alpha_sum;
sigma[t]= factor;
log_likelihood+= log(factor);
for(j= 0;j<N;j++)
alpha[t][j]*= factor;
}
for(i= 0;i<N;i++){
int j,k;
beta[T-1][i]= 1.0;
gamma_T_minus_1[i]= alpha[T-1][i];
for(j= 0;j<N;j++)
a_bar[i][j]= 0.0;
for(k= 0;k<M;k++)
b_bar[i][k]= 0.0;
b_bar[i][o[T-1]]+= gamma_T_minus_1[i];
eta[i]= 0.0;
}
for(t= T-2;t>=0;t--){
int i;
for(i= 0;i<N;i++){
int j;
float gamma_t_i;
float sum= 0.0;
for(j= 0;j<N;j++){
float temp;
temp= a[i][j]*b[j][o[t+1]]*beta[t+1][j];
a_bar[i][j]+= alpha[t][i]*temp*sigma[t+1];
sum+= temp;
}
beta[t][i]= sigma[t+1]*sum;
gamma_t_i= alpha[t][i]*beta[t][i];
b_bar[i][o[t]]+= gamma_t_i;
eta[i]+= gamma_t_i;
if(t==0)
pi_bar[i]= gamma_t_i;
}
}
for(i= 0;i<N;i++){
int j,k;
for(j= 0;j<N;j++)
a_bar[i][j]/= eta[i];
for(k= 0;k<M;k++)
b_bar[i][k]/= eta[i]+gamma_T_minus_1[i];
}
return(log_likelihood);
}
void print_float_array_2(a,N,M,name)
int N,M;
float a[][M];
char name[];
{
int i,j;
printf("%s:",name);
for(i= 0;i<N;i++){
for(j= 0;j<M;j++)
printf("\t%.2f",a[i][j]);
printf("\n");
}
}
void print_int_array_2(a,N,M,name)
int N,M;
int a[][M];
char name[];
{
int i,j;
printf("%s:",name);
for(i= 0;i<N;i++){
for(j= 0;j<M;j++)
printf("\t%d",a[i][j]);
printf("\n");
}
}
void print_float_array_1(a,N,name)
int N;
float a[];
char name[];
{
int i;
printf("%s:",name);
for(i= 0;i<N;i++)
printf("\t%.2f",a[i]);
printf("\n");
}
void print_int_array_1(a,N,name)
int N;
int a[];
char name[];
{
int i;
printf("%s:",name);
for(i= 0;i<N;i++)
printf("\t%d",a[i]);
printf("\n");
}
void parse_command_line(argc,argv)
int argc;
char*argv[];
{
int i;
int seed= 0;
if(argc>1)
for(i= 1;i<argc;i++)
if(argv[i][0]= '-')
switch(argv[i][1]){
case'n':
N= atoi(argv[++i]);
break;
case'm':
M= atoi(argv[++i]);
break;
case't':
T= atoi(argv[++i]);
break;
case'l':
L= atoi(argv[++i]);
break;
case's':
seed= atoi(argv[++i]);
break;
case'o':
output= 0;
break;
case'r':
start= 1;
break;
}
srand(seed);
}
void initialize_data(a,b,pi,i,o,N,M,T)
int N,M,T;
float a[][N],b[][M],pi[];
int i[],o[];
{
random_transition_matrix(a,N);
random_output_matrix(b,N,M);
random_initial_probabilities(pi,N);
random_states(a,pi,i,N,T);
random_output(b,i,o,M,T);
}
void random_starting_point(a,b,pi,N,M,T)
int N,M,T;
float a[][N],b[][M],pi[];
{
random_transition_matrix(a,N);
random_output_matrix(b,N,M);
random_initial_probabilities(pi,N);
}
void print_results(a,b,pi,N,M)
int N,M;
float a[][M],b[][M],pi[];
{
print_float_array_1(pi,N,"pi");
printf("\n");
print_float_array_2(a,N,N,"a");
printf("\n");
print_float_array_2(b,N,M,"b");
}
main(argc,argv)
int argc;
char*argv[];
{
parse_command_line(argc,argv);
{
int l;
float a[N][N],b[N][M],pi[N];
float a_bar[L+1][N][N],b_bar[L+1][N][M],pi_bar[L+1][N];
int i[T],i_star[T],o[T];
float actual_log_likelihood,log_likelihood;
initialize_data(a,b,pi,i,o,N,M,T);
if(output){
printf("\nActual values:\n");
print_results(a,b,pi,N,M);
}
actual_log_likelihood=
forward_backward(a,b,pi,a_bar[0],b_bar[0],pi_bar[0],
o,N,M,T);
if(output)
printf("Log likelihood = %.2f for actual values.\n\n",
actual_log_likelihood);
if(start==1){
random_starting_point(a_bar[0],b_bar[0],pi_bar[0],N,M,T);
if(output==1){
printf("Beginning iteration 1 at random starting point:\n");
print_results(a_bar[0],b_bar[0],pi_bar[0],N,M);
}
}
else
if(output){
printf("New values:\n");
print_results(a_bar[0],b_bar[0],pi_bar[0],N,M);
}
for(l= 0;l<L;l++){
log_likelihood=
forward_backward(a_bar[l],b_bar[l],pi_bar[l],
a_bar[l+1],b_bar[l+1],pi_bar[l+1],
o,N,M,T);
if(output){
printf("Log likelihood = %.2f for iteration %d.\n\n",
log_likelihood,l+1);
printf("New values:\n");
print_results(a_bar[l+1],b_bar[l+1],pi_bar[l+1],N,M);
}
}
if(output){
printf("\nActual values:\n");
print_results(a,b,pi,N,M);
printf("Log likelihood = %.2f for actual values.\n\n",
actual_log_likelihood);
}
}
}