from interface.h cut #define MAX_TABLE_NUMBER 4

put /*  #define COMPUTE_GAUSSIAN_VERSION  */ in options.h
put  #define NUMBER_TABLES 2  in scconst.h
put #define NUMBER_CLASES 3 in scconst.h
put #define MAX_TABLE_NUMBER 2   /* Same as NUMBER_TABLES. **/ in scconst.h
put #define NUM_DIM_IN_ORIG_MATRIX 14 in scconst.h
and in interface.c
for both_class_covars[][][][] and both_class_means[][][] made the max size
of the matrix be NUM_DIM_IN_ORIG_MATRIX  (Then changed in multivariate_like.c
where pass these in).  (get_gauss_param_all_classes2(), compute_submatrices2())

In scconst.h, put
#ifdef COMPUTE_GAUSSIAN_VERSION
  #define MAX_NUM_SCORE_DIM 14
#else
  #define MAX_NUM_SCORE_DIM 6
#endif


 double m_single[MAX_TABLE_NUMBER],
         b_single[MAX_TABLE_NUMBER];  /*  Like line for singlecoil. */


 /*************************** PAIRDIFF LIKELIHOOD STUFF. *********************/
 double differ_determinants[MAX_CLASS_NUMBER];
 double differ_inverse_covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM];
 double differ_covars_submatrix[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM];
 double differ_means_submatrix[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM];

 int number_differ_score_dim =0;
 int number_differ_lib=0;
 int differ_window_length = 28;
 int which_differentiator=1;   /** Default is just the score for the window **/
                           /** 2 means to give each residue a pair of scores**/
                           /** corresponding to the max and min of the      **/
                           /** windows containing it.                       **/
 int differ_functnum=0;
#endif


#ifdef TEST_VERSION
  char differ_class_sc_filenames[MAX_CLASS_NUMBER][MAXLINE];
  double differ_means[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM];
  double differ_covars[MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM];
  char differ_gauss_param[MAXLINE];
  char differ_lib[MAXFUNCTNUM];   /*  Distance values for PairCoilDiff */
  extern int differ_functnum;     
#ifdef TEST_VERSION

#ifdef TEST_VERSION
  double prior_freq_single[MAX_TABLE_NUMBER], 
         prior_freq_pair[MAX_TABLE_NUMBER];
  int which_priors =0, which_priorp =0;
  int good_turing_fixed_disc =0;    /** If set to 1 do the good_turing_fixed_disc estimate of probs*/
  int structural_pos[POSNUM+1];  /** Holds list of which positions are **/
                               /** structurally important.  All others **/
                               /** get genbnk probabilities....       **/
                               /** Value -1 indicates no more entries. **/
#endif

 int old_num_dim_differ =0;
                          /* The gauss param file for multiple distances is */
                         /* contains the parameters for all distances.     */
#ifdef TEST_VERSION
  compute_multivariate_num_differ_dim(&number_differ_score_dim,
			       number_differ_lib,
			       differ_functnum, &old_num_dim_differ,
			       which_differentiator);
#endif

cut
double both_covars_submatrix[2][MAX_CLASS_NUMBER][MAX_NUM_SCORE_DIM][MAX_NUM_SCORE_DIM];



#ifdef TEST_VERSION
/*************************************************************************/
/******************Now do gauss parameters for PairCoilDiff method.  *****/
/*************************************************************************/
/**** Note the "2" parameter represents that are 2 classes (dimers, trimers)***/
/**** not three, since just differentiating so don't need pdb-.    ************/

  if (differ_gauss_param[0] != ',') {
    char differ_lib_hack[2][MAXFUNCTNUM];
                     /** If are computing max and min window scores, **/
                     /** then need to extract both dimenion i and   **/
                     /** i + old_num_dim_differ/2. Treat them like they **/
                     /** were from another table.   ***/


    get_gauss_param_all_classes2(differ_class_sc_filenames, 
				 old_num_dim_differ,
				 differ_means, differ_covars,
				 2, differ_gauss_param);
	
    if (which_differentiator ==2) {
      for (i=0; i<number_differ_score_dim/2; i++) {
	differ_lib_hack[0][i] = differ_lib[i];
	differ_lib_hack[1][i] = differ_lib[i];
      }
      compute_submatrices2(differ_means,differ_means_submatrix,
			 differ_covars,2, 
			 differ_inverse_covars,
			 differ_determinants, differ_lib_hack,
			 old_num_dim_differ/2, old_num_dim_differ/2,
			 number_differ_score_dim/2, number_differ_score_dim/2,
			 1);
    }
    else
      compute_submatrices2(differ_means,differ_means_submatrix,
			 differ_covars,2, 
			 differ_inverse_covars,
			 differ_determinants, differ_lib,
			 old_num_dim_differ, 0,
			 number_differ_score_dim, 0,
			 1);

/************/
	  for (class=0; class<2; class++) {
	    fprintf(stderr,"\n\nDiffer Mean Submatrix %d:\n",class);
	    print_matrix(differ_means_submatrix[class],1,
		        number_differ_score_dim,stderr);
	    fprintf(stderr,"\n\nDiffer Inver Covar Submatrix %d:\n", class);
	    print_matrix(differ_inverse_covars[class],
			 number_differ_score_dim,number_differ_score_dim,
			 stderr);
	    
	  }
/**********/

    fprintf(stderr,"\nDet0 =%lf, det1= %lf\n",
	    differ_determinants[0],differ_determinants[1]);
	
    fprintf(stderr,"\nnew_num_dim_differ=%d, old_num_dim_differ=%d,", number_differ_score_dim, old_num_dim_differ);

	  

  }
#endif

#ifdef TEST_VERSION
      case XK_A:         /** Switch between unweighted avg and  **/
      case XK_a:         /** weighted avg coil score.             **/
	weighted_avg = !weighted_avg;
	if (Coil_Score !=0) { /** CoilScore ==0 means not doing coil score. **/
	  ShowSeq(lib,differ_lib,multi_lib,
		  m,b,m_single,b_single,mode,-1,-1, bound);
	  if (zoomptr) Zoomer();
	}
	break;


      case XK_b:
      case XK_B:         /** For CoilScore, change how deal with reg shift. **/
	start_coil_at_reg_shift = !start_coil_at_reg_shift;
	if (Coil_Score !=0) { /** CoilScore ==0 means not doing coil score. **/
	  ShowSeq(lib,differ_lib,multi_lib,
		  m,b,m_single,b_single,mode,-1,-1, bound);
	  if (zoomptr) Zoomer();
	}
	break;


      case XK_R:
      case XK_r:
	offset_to_use = (offset_to_use +1) % 8;   /* Cycle through offsets */
/***	switch_gauss_param(offset_to_use);  **/
	ShowSeq(lib,differ_lib,multi_lib,
		m,b,m_single,b_single,mode,1,1, bound);
	if (zoomptr) Zoomer();
        break;
      case XK_s:        /*  Use single probabilities. */
      case XK_S:
	if (mode & PAIRCOIL_PAIRS) {
	  mode -= PAIRCOIL_PAIRS; /** Turn it off **/
	  ShowSeq(lib,differ_lib,multi_lib,
		m,b,m_single,b_single,mode,1,1, bound);
	  if (zoomptr) Zoomer();
	}
	break;

      case XK_l:        /*  Use pair probabilities at lib distances */
      case XK_L:
	if (!(mode & PAIRCOIL_PAIRS)) {
	  mode |= PAIRCOIL_PAIRS;  /* Turn it on. */
	  ShowSeq(lib,differ_lib,multi_lib,
		  m,b,m_single,b_single,mode,1,1, bound);
	  if (zoomptr) Zoomer();
	}
	break;
#endif



changed   
  initialize(&number_classes, &number_multi_lib[0], window_length, scale0s,
	     scale0p,fpin[0],
	     &likelihoods[0][0], &pir_name[0], print, gauss_param, 
	     differ_gauss_param,
	     &mode, prior_freq_single, prior_freq_pair,
	     structural_pos);
to
  initialize(&number_classes, &number_multi_lib[0], window_length, scale0s,
	     scale0p,fpin[0],
	     &likelihoods[0][0], &pir_name[0], print, gauss_param, 
	     &mode, prior_freq_single, prior_freq_pair,
	     structural_pos);



changed 
OpenScreen(int mode, double log_bound, FILE *fin, FILE *flog, 
	        FILE* flog_coil_conflicts,FILE *fout_coils,
	        FILE *fout,
		double *m, double *b, double *m_single, double *b_single, 
		char lib[MAXFUNCTNUM], 
	        char differ_lib[MAXFUNCTNUM], 
	        char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	        int main_method, 
	        int main_preprocessor_method,
	        int *seqcnt, int which_priors, int which_priorp,
	        double prior_freq_single[MAX_TABLE_NUMBER],
		double prior_freq_pair[MAX_TABLE_NUMBER], 
	        int good_turing_fixed_disc, int structural_pos[POSNUM+1])

to
OpenScreen(int mode, double log_bound, FILE *fin, FILE *flog, 
	        FILE* flog_coil_conflicts,FILE *fout_coils,
	        FILE *fout,
		double *m, double *b, double *m_single, double *b_single, 
		char lib[MAXFUNCTNUM], 
	        char differ_lib[MAXFUNCTNUM], 
	        char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	        int main_method, 
	        int main_preprocessor_method,
	        int *seqcnt)


changed
      finish_log(mode,log_bound,fin,flog,flog_coil_conflicts,fout_coils,
		 fout, 
		 m,b, m_single, b_single,
		     lib,differ_lib,multi_lib, main_method, main_table,
		     main_preprocessor_method, seqcnt, avg_max, which_priors,
		     which_priorp, prior_freq_single, prior_freq_pair, 
		     good_turing_fixed_disc, structural_pos);

to
      finish_log(mode,log_bound,fin,flog,flog_coil_conflicts,fout_coils,
		 fout, 
		 m,b, m_single, b_single,
		     lib,differ_lib,multi_lib, main_method, main_table,
		     main_preprocessor_method, seqcnt, avg_max);

changed
  if (mode & TST_MODE0) 
    recalc_prob(sequence, 0, mode, which_priors, which_priorp,
		prior_freq_single, prior_freq_pair, good_turing_fixed_disc,
		structural_pos);
  if (mode & TST_MODE1)
    recalc_prob(sequence,1, mode, which_priors, which_priorp,
		prior_freq_single, prior_freq_pair, good_turing_fixed_disc,
		structural_pos);
to
  if (mode & TST_MODE0) 
    recalc_prob(sequence, 0, mode);
  if (mode & TST_MODE1)
    recalc_prob(sequence,1, mode);


/*************************************************************************/
/********     ROUND 2 of cuts. *******************************************/
/*************************************************************************/

int number_classes=0;  
int weighted_avg = 0;  /*  Determines which method for determining coil */
                         /*  score will be used in DimerTrimerScore.      */
char table_diff_stat_filename[MAXLINE]="/dev/null";
char weightfile_outname[MAXLINE]="/dev/null";

  "key 'r':   Cycle through offsets 0-7 for register (7=combo reg)",
  "key 'b':   For Coil score, toggle whether start new coils at",
  "             a register shift (break in structure).",
  "key 'a':   For Coil score, toggle between unweighted and weighted avg",
  "",


FILE *flog_coil_conflicts=NULL
  extern int number_classes;  



  double upper_bound;   /* In DEBUG_MODE (for printing out the predicted    */
                        /* heptad repeat), scores in  [bound,upper_bound]   */
                        /* are printed in capital letters.                  */



changed
  initialize(&number_classes, &number_multi_lib[0], window_length, scale0s,
	     scale0p,fpin[0],
	     &likelihoods[0][0], &pir_name[0], print, gauss_param, 
	     &mode, prior_freq_single, prior_freq_pair,
	     structural_pos);
to 
  initialize(&number_multi_lib[0], window_length, scale0s,
	     scale0p,fpin[0],
	     &likelihoods[0][0], &pir_name[0], print, gauss_param, 
	     &mode);

changed

  get_defaults(argv[1], &mode, &log_bound, &fgin, fpin, 
	       &ftotal_like, &fout, 
	       &flog, &flog_coil_conflicts, 
	       &fout_coils, &by_coil_or_seq, likelihoods,
	       pir_name, lib, multi_lib, 
	       &pair_functnum, multi_functnum,
	       print, &main_method, &main_preprocessor_method, 
	       &main_table, &number_tables,  &offset_to_use,  
	       &avg_max, &weighted_avg,   &Coil_Score,
	       table_diff_stat_filename, weightfile_outname,
	       &ps_res_per_line, &number_classes, 
	       class_sc_filenames, 
	       gauss_param,  number_multi_lib,
	       init_class_prob, 
	       &table_to_remove_from,  
	       command_line, window_length, scale0s, scale0p,
	       &which_differentiator);
to


  get_defaults(argv[1], &mode, &log_bound, &fgin, fpin, 
	       &ftotal_like, &fout, 
	       &flog, 
	       &fout_coils, &by_coil_or_seq, likelihoods,
	       pir_name, lib, multi_lib, 
	       &pair_functnum, multi_functnum,
	       print, &main_method, &main_preprocessor_method, 
	       &main_table, &offset_to_use,  
	       &avg_max,   &Coil_Score,
	       &ps_res_per_line,  
	       class_sc_filenames, 
	       gauss_param,  number_multi_lib,
	       init_class_prob, 
	       &table_to_remove_from,  
	       command_line, window_length, scale0s, scale0p);


cut     int old_num_dim_table[2];
        int new_num_dim_table[2];
 
and
compute_multivariate_num_dim(mode, &number_score_dim,
			       number_multi_lib,multi_functnum, number_tables,
			       new_num_dim_table, old_num_dim_table);


changed

  if (number_classes >0)  {        /*** Get gaussian param for the classes. */
    if (ftotal_like) {      /** Want to output total gauss like over classes*/
      for (i=0; i<number_classes; i++)  /* for various init_prob settings.  */
	init_class_prob[i]=1;   /** All 1 values is flag to just output     */
      init_totals(total_gauss_like); /** gauss values, not like values in   */
      }                              /** convert_raw_scores_to_gauss_like.   */
  
to

  if (ftotal_like) {      /** Want to output total gauss like over classes*/
    for (i=0; i<number_classes; i++)  /* for various init_prob settings.  */
      init_class_prob[i]=1;   /** All 1 values is flag to just output     */
    init_totals(total_gauss_like); /** gauss values, not like values in   */
  }                              /** convert_raw_scores_to_gauss_like.   */


Replace int number_multi_lib[MAX_TABLE_NUMBER]
with  int num_dist[MAX_TABLE_NUMBER] almost everywhere

in conjunction with replacing multi_functnum with a variable indicating
if distances are each a dimension, or if should combine into a single
library...
i.e. change 
  int multi_functnum[MAX_TABLE_NUMBER]
    to 
      int combine_dist[MAX_TABLE_NUMBER];


CHANGED:

    get_gauss_param_all_classes2(class_sc_filenames[i], 
				 old_num_dim_table[0]+old_num_dim_table[1],
				 both_class_means[i], both_class_covars[i],
				 number_classes, gauss_param[i]); 
to
      get_gauss_param_all_classes2(class_sc_filenames[i], 
				     6*combine_dist[0] + 1 +
				     6*combine_dist[1] + 1,
				    both_class_means[i], both_class_covars[i],
				    gauss_param[i]);

changed 
      compute_submatrices2(both_class_means[i],both_means_submatrix[i],
				   both_class_covars[i], 
				   both_inverse_covars[i],
				   both_determinants[i], multi_lib,
			           old_num_dim_table[0], old_num_dim_table[1],
			           new_num_dim_table[0], new_num_dim_table[1],
			           mode & MULTI_TRIMER_PAIRS);
to
      compute_submatrices2(both_class_means[i],both_means_submatrix[i],
				   both_class_covars[i], 
				   both_inverse_covars[i],
				   both_determinants[i], multi_lib,
			           6*combine_dist[0] + 1, 
			           6*combine_dist[1] + 1
			           (num_dist[0]-1)*combine_dist[0] + 1, 
			           (num_dist[1]-1)*combine_dist[1] + 1);



added      number_score_dim = (num_dist[0]-1)*combine_dist[0] + 1 +
			           (num_dist[1]-1)*combine_dist[1] + 1;



changed
    log_file_header(flog, flog_coil_conflicts,  mode, 
		    argc, argv, avg_max, log_bound, 
		    preprocessor_method, preproc_table, log_offset_to_use, 
		    start_coil_at_reg_shift, weighted_avg, main_method, 
		    main_table);
to

  if ( (mode & PRN_MODE) && flog ){
    log_file_header(flog,  mode, 
		    argc, argv, avg_max, log_bound, 
		    preprocessor_method, preproc_table, log_offset_to_use, 
		    start_coil_at_reg_shift, main_method, 
		    main_table);

from that function, cut stuff for log_coil_conflicts
and cut
      if (weighted_avg == 0) {
	  fprintf(flog, "\n Averaging over coils was done by coil length.");
      }
      else  { /* weighted_avg ==1 */
	fprintf(flog, "\n Averaging over coils was done using coil length weighted at each position by the preprocessor coil likelihood.");
      }


changed 


  PairCoilData(fgin,fpin,&number_tables, mode & PROLINE_FREE_MODE,
	       table_to_remove_from, argv[1], mode);
                                  /* If fpin[1] != NULL this will call    */
to
  PairCoilData(fgin,fpin, mode & PROLINE_FREE_MODE,
	       table_to_remove_from, argv[1], mode);


changed
    get_likelihood_line(likelihoods, m, b, m_single, b_single,
		      lib, pair_functnum,pir_name,mode,number_tables);
to

    get_likelihood_line(likelihoods, m, b, m_single, b_single,
		      lib, pair_functnum,pir_name,mode,NUMBER_TABLES);


changed
  OpenScreen(mode,log_bound,fin,flog,flog_coil_conflicts, fout_coils,
	     fout,  m,b,m_single, b_single,
	     lib,differ_lib,multi_lib,
	     main_method,main_preprocessor_method, &seqnum);
to
  OpenScreen(mode,log_bound,fin,flog, fout_coils,
	     fout,  m,b,m_single, b_single,
	     lib,multi_lib,
	     main_method,main_preprocessor_method, &seqnum);


changed
      finish_log(mode,log_bound,fin,flog,fout_coils,
		 fout, 
		 m,b, m_single, b_single,
		     lib,multi_lib, main_method, main_table,
		     main_preprocessor_method, seqcnt, avg_max);
to
      finish_log(mode,log_bound,fin,flog,fout_coils,
		 fout, 
		 m,b, m_single, b_single,
		     lib,multi_lib, main_method, main_table,
		     main_preprocessor_method, seqcnt, avg_max);


Changed 

	NextSeq(fin,lib,differ_lib,multi_lib,
		m,b,m_single,b_single, 
		mode,bound,flog,flog_coil_conflicts,fout_coils,
		fout, which_priors, which_priorp, prior_freq_single, 
		prior_freq_pair, good_turing_fixed_disc, structural_pos);
to
	NextSeq(fin,lib,multi_lib,m,b,m_single,b_single, 
		mode,bound,flog,fout_coils,fout);


changed
	PrevSeq(fin,lib,differ_lib,multi_lib,
		m,b,m_single,b_single,
		mode,bound, which_priors,which_priorp, prior_freq_single,
		prior_freq_pair, good_turing_fixed_disc, structural_pos);
to
	PrevSeq(fin,lib,multi_lib,m,b,m_single,b_single,mode,bound);


changed ShowSeq(lib,differ_lib,multi_lib,
		m,b,m_single,b_single,mode,1,0, bound);
to
        ShowSeq(lib,multi_lib,m,b,m_single,b_single,mode,1,0, bound);


cut
	if (flog_coil_conflicts) sclose(flog_coil_conflicts);


changed
	    type_class_score_convert(sequence,all_scores,bound,
				    mode & ONLY_COILED_CLASSES,number_tables,
				    number_classes);
to
	    type_class_score_convert(sequence,all_scores,bound,
				    mode & ONLY_COILED_CLASSES);

changed
	if (method == MultiCoil) 
	  table = table % number_classes;
	else 
	  table = table % number_tables;
to
	if (method == MultiCoil) 
	  table = table % NUMBER_CLASSES;
	else 
	  table = table % NUMBER_TABLES;


changed
NewSeq (int mode, Sequence sequence, int which_priors, int which_priorp,
	double prior_freq_single[MAX_TABLE_NUMBER],
	double prior_freq_pair[MAX_TABLE_NUMBER], int good_turing_fixed_disc,
	int structural_pos[POSNUM+1])
to
NewSeq (int mode, Sequence sequence)




In output_seq()
changed
  case MultiCoil:
/****/
    if (fout_coils) 
      /*** For pos files coils, does a log file version  of coil/seq score. **/
      output_pos_scores(fout_coils, sequence, all_scores, log_bound, mode, 
			by_coil_or_seq, weighted_avg);

to

  case MultiCoil:
/****/
    if (fout_coils) 
      /*** For pos files coils, does a log file version  of coil/seq score. **/
      output_pos_scores(fout_coils, sequence, all_scores, log_bound, mode,
			2, 1);

SO ALWAYS TO SEQUENCE SCORE and Weighted average (weighted by coil prob.).


Cut
  case MultiCoil
    if (flog_coil_conflicts) 
      coil_conflicts(mode,all_scores,all_scores,sequence, seqnum,log_bound, 
		     log_bound,number_tables, flog_coil_conflicts,avg_max);
and
  case PairCoilDiffAvg:
    if (flog_coil_conflicts) {

      coil_conflicts(mode,all_scores,all_preprocess_like,sequence, seqnum,
		     .5, log_bound, number_tables, flog_coil_conflicts,
		     avg_max);

    }
    break;


cut
      else if (main_method == PairCoilDiff)  
	                      /* Output max score for each dimension. */
	           /** Had to do a hack since tuple_out2 expects number_lib  */
	          /** to be array of size num_tab, so pass in 1 for num_tab */
	tuple_output2(sequence, mode, fout, all_scores, 1,
		      &number_differ_lib,log_bound, number_differ_score_dim);
    

in preprocessor_score() changed
      num_multilib= compute_num_multilib(tablenum, number_multi_lib,
					 mode & MULTI_TRIMER_PAIRS);
to
      num_score_dim= combine_dist[tablenum]*num_dist[tablenum] + 
	               (1-combine_dist[tablenum]); 
and
      functnum = multi_functnum[tablenum];
to
      functnum = combine_dist[tablenum]*num_dist[tablenum] +
	          (1 - combine_dist[tablenum]);

changed
	average_score_over_coils3(sequence, all_preprocess_like[tablenum+3],
				  all_preprocess_like[tablenum],
			     all_preprocess_like[2+3],/** Total Coil Like. **/
 			        weighted_avg, offset_to_use,
				all_preproc_offsets[tablenum],
			        start_coil_at_reg_shift, bound,
				Coil_Score -1);
to
	average_score_over_coils3(sequence, all_preprocess_like[tablenum+3],
				  all_preprocess_like[tablenum],
			     all_preprocess_like[2+3],/** Total Coil Like. **/
 			        offset_to_use,
				all_preproc_offsets[tablenum],
			        start_coil_at_reg_shift, bound,
				Coil_Score -1);


From ScoreSeq()
cut

  int use_pairs=1;
      if (tablenum ==0) use_pairs =1;  /*  Use pairs for cctb */
      else if (tablenum ==1) use_pairs = (mode & MULTI_TRIMER_PAIRS);  
               /* Do what config file said to do for trimers. **/

replaced

	functnum = multi_functnum[tablenum];   /* For use in scscore.c **/
	num_multilib = compute_num_multilib(tablenum,number_multi_lib, 
	for (dist=0; dist<num_multilib; dist++) {
	  if (number_multi_lib[tablenum] >1) 
	    local_lib = &multi_lib[tablenum][dist];
	  else local_lib = multi_lib[tablenum];
by
	for (dist=0; dist<num_score_dim; dist++) {
	  if (number_dist[tablenum] >1) 
	    local_lib = &multi_lib[tablenum][dist];
	  else local_lib = multi_lib[tablenum];
	  dimension = compute_dimension2(tablenum, dist,
					num_dist, combine_dist);




/*************************************************************************/
/**********************ADD BACK EVENTUALLY *******************************/
From scoreseq cut


      case PairCoilDiff:
	functnum = differ_functnum;   
	for (dimension=0; dimension<number_differ_lib; dimension++) {
	  if (number_differ_lib >1) { 
	    local_lib = &differ_lib[dimension];
	  }
	  else local_lib = differ_lib;
	

	  PairCoilDifferDimension(mode, sequence, local_lib, &maxsc,
				  all_preproc_offsets[preproc_table],
				  all_preprocess_like[preproc_table],
				  all_scores,
				  all_offsets, dimension,
				  Offset_to_Use, number_differ_score_dim,
				  bound);	
	
	}
	break;


/************************************************************************/
changed

    if ( (Method != MultiCoil)  && (Method !=PairCoilDiff)) 
      get_offsets(all_scores, sequence,all_offsets,number_tables);
to
    if (Method != MultiCoil) 
      get_offsets(all_scores, sequence,all_offsets,NUMBER_TABLES);
    else if (!(mode & RAW_OUT)) {


CUT

/***********Do conversions on PairCoilDiff scores, using preprocessor. **/
/*********** Note for differentiator there are only 2 possible classes **/
/*********** (dimer and trimer). **********/
      if (Method == PairCoilDiff) {
	convert_raw_scores_to_gauss_prob_like2(all_scores,sequence.seqlen,
			  number_tables, differ_means_submatrix,
			  differ_inverse_covars,differ_determinants, 2,
			  init_class_prob, number_differ_score_dim,
			   0, bound, Offset_to_Use,0);
	if (Preprocessor_Method == MultiCoil) 
	  preproc_res_like = &all_preprocess_like[preproc_table+3][0][0];
	else preproc_res_like = &all_preprocess_like[preproc_table][0][0];


/*  Only use window scores that lie completely in coil */
	if ( (which_differentiator == 3) || (which_differentiator ==4))
	  zero_out_non_coils(all_scores, all_preprocess_like[preproc_table],
			     sequence.seqlen, bound);

	if (which_differentiator == 1) 
	  zero_out_bad_windows(differ_window_length, 
			       all_scores,all_preprocess_like[preproc_table],
			       sequence.seqlen,bound);

	copy_offsets(all_preproc_offsets[preproc_table],sequence, 
		      all_offsets,2, all_scores, Offset_to_Use);
	if (Coil_Score) /* Value of 1 means do average, 2 means do max. */
	  for (tablenum=0; tablenum<2; tablenum++) {
	    average_score_over_coils3(sequence, all_scores[tablenum+3],
				    all_scores[tablenum],
				    preproc_res_like,  
				    /** Total Coil Like. **/
 			        weighted_avg, offset_to_use,
				  all_preproc_offsets[preproc_table],
			        start_coil_at_reg_shift, bound,
				Coil_Score -1);
	}
      }



cut
    if (rescore_seq==-1 && !scored_already && (Method==PairCoilDiff)) {
      if ( (which_differentiator == 3) || (which_differentiator ==4))
	zero_out_non_coils(all_scores, all_preprocess_like[preproc_table],
			     sequence.seqlen, bound);
      if (which_differentiator == 1) /*  Only use window scores that lie */
	zero_out_bad_windows(differ_window_length, /* completely in coil */
			       all_scores, all_preprocess_like[preproc_table],
			       sequence.seqlen,bound);
    }


changed
	get_seq_scores(seq_scores, sequence, all_scores[0+3],
		                        all_scores[1+3],bound, weighted_avg);

to
	get_seq_scores(seq_scores, sequence, all_scores[0+3],
		                        all_scores[1+3],bound);


cut


      else if (Method == PairCoilDiff)  {
	if (Preprocessor_Method == MultiCoil) 
	  preproc_res_like = &all_preprocess_like[preproc_table+3][0][0];
	else preproc_res_like = &all_preprocess_like[preproc_table][0][0];

	
	for (tablenum=0; tablenum<2; tablenum++)
	  average_score_over_coils3(sequence, all_scores[tablenum+3],
				    all_scores[tablenum],
				    preproc_res_like,  
				    /** Total Coil Like. **/
				    weighted_avg, offset_to_use,
				    all_offsets[tablenum],
				    start_coil_at_reg_shift, bound,
				    Coil_Score -1);
      }
    


changed
ShowSeq(char lib[MAXFUNCTNUM], char differ_lib[MAXFUNCTNUM],
	char  multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	double *m, double *b,
	 double *m_single, double *b_single,
	 int mode, int rescore_sequence, int rescore_preproc, double bound)
to
ShowSeq(char lib[MAXFUNCTNUM], 
	char  multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
	double *m, double *b,
	 double *m_single, double *b_single,
	 int mode, int rescore_sequence, int rescore_preproc, double bound)

changed


    all_scores = ScoreSeq(lib, differ_lib, multi_lib, m, b,m_single, b_single,
		    mode, table, 
		    method, preprocessor_method,
		    offset_to_use, &maxscore,  
		    rescore_sequence, rescore_preproc, bound);
to
    all_scores = ScoreSeq(lib,  multi_lib, m, b,m_single, b_single,
		    mode, table, 
		    method, preprocessor_method,
		    offset_to_use, &maxscore,  
		    rescore_sequence, rescore_preproc, bound);

/******************************ROUND 3 OF CHANGES **************************/

changed
  initialize(&num_dist[0], window_length, scale0s,
	     scale0p,fpin[0],
	     &likelihoods[0][0], &pir_name[0], print, gauss_param, 
	     &mode);
to
  initialize(&num_dist[0], window_length, scale0s,
	     scale0p,fpin[0],
	     &likelihoods[0][0], &pir_name[0], print, gauss_param, 
	     &mode, init_clas_prob);



changed
void output_seq(char lib[MAXFUNCTNUM],char differ_lib[MAXFUNCTNUM],
		char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
		double *m,double *b,
		double *m_single, double *b_single, 
		int mode, 
		double log_bound,FILE *flog, FILE *flog_coil_conflicts,
		FILE *fout_coils,
		FILE *fout,  
		int avg_max,
		int main_method, int main_preprocessor_method,
		int main_table)
to
void output_seq(char lib[MAXFUNCTNUM],char differ_lib[MAXFUNCTNUM],
		char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
		double *m,double *b,
		double *m_single, double *b_single, 
		int mode, 
		double log_bound,FILE *flog, 
		FILE *fout_coils,
		FILE *fout,  
		int avg_max,
		int main_method, int main_preprocessor_method,
		int main_table)
cut
    if (flog_coil_conflicts) sclose(flog_coil_conflicts);



changed


    convert_raw_scores_to_gauss_prob_like2(all_preprocess_like,sequence.seqlen,
				 NUMBER_TABLES,means_submatrix,inverse_covars,
				 determinants, NUMBER_CLASSES, init_class_prob,
				 number_score_dim,
				     mode & ONLY_COILED_CLASSES, 
				     bound,Offset_to_Use,  1);
 to
    convert_raw_scores_to_gauss_prob_like2(all_preprocess_like,sequence.seqlen,
				 NUMBER_TABLES,means_submatrix,inverse_covars,
				 determinants, NUMBER_CLASSES, init_class_prob,
				 number_score_dim,
				     mode & ONLY_COILED_CLASSES, 
				     bound,Offset_to_Use);
 twice.





Changed

  if (ftotal_like) {      /** Want to output total gauss like over classes*/
    for (i=0; i<number_classes; i++)  /* for various init_prob settings.  */

to 

  if (ftotal_like) {      /** Want to output total gauss like over classes*/
    for (i=0; i<NUMBER_CLASSES; i++)  /* for various init_prob settings.  */
 


changed
      get_gauss_param_all_classes2(class_sc_filenames[i], 
				   num_table_dimensions(7,combine_dist[0]) +
				   num_table_dimensions(7,combine_dist[1]),
				    both_class_means[i], both_class_covars[i],
				   number_classes, gauss_param[i]);
to
      get_gauss_param_all_classes2(class_sc_filenames[i], 
				   num_table_dimensions(7,combine_dist[0]) +
				   num_table_dimensions(7,combine_dist[1]),
				    both_class_means[i], both_class_covars[i],
				   NUMBER_CLASSES, gauss_param[i]);


Changed
	  preproc_table = (preproc_table +1) % number_classes;
to
  preproc_table = (preproc_table +1) % NUMBER_CLASSES;


Changed 
	    type_class_score_convert(sequence,all_scores,bound,
				     mode & ONLY_COILED_CLASSES, number_tables,
				     NUMBER_CLASSES);
to
	    type_class_score_convert(sequence,all_scores,bound,
				     mode & ONLY_COILED_CLASSES);


Changed
      get_gauss_param_all_classes2(class_sc_filenames[i], 
				   num_table_dimensions(7,combine_dist[0]) +
				   num_table_dimensions(7,combine_dist[1]),
				    both_class_means[i], both_class_covars[i],
				   NUMBER_CLASSES, gauss_param[i]);
to
      get_gauss_param_all_classes2(class_sc_filenames[i], 
				   num_table_dimensions(7,combine_dist[0]) +
				   num_table_dimensions(7,combine_dist[1]),
				    both_class_means[i], both_class_covars[i],
				   gauss_param[i]);
Changed
      if (Coil_Score ==1)
	if (weighted_avg)
	  strcat(MethodTitle,"WtdAvg");
	else strcat(MethodTitle,"Avg");
to
    if (Coil_Score) {
      if (Coil_Score ==1)
	strcat(MethodTitle,"WtdAvg");


From function switch_gauss_param() cut
  else if (Method == PairCoilDiff) {
    determinants= &differ_determinants[0];
    inverse_covars= &differ_inverse_covars[0][0][0];
    means_submatrix= &differ_means_submatrix[0][0];
  }


/********************************************************************/

In interface.h
changed
void output_seq(char lib[MAXFUNCTNUM],char lib_differ[MAXFUNCTNUM],
		char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
		double *m,double *b,
		double *m_single, double *b_single,
		int mode, 
		double bound, FILE *flog, FILE *flog_coil_conflicts,
		FILE *fout_coils,
		FILE *fout, 
		int avg_max,
		int main_method, int main_preprocessor_method, int main_table);


to

void output_seq(char lib[MAXFUNCTNUM],
		char multi_lib[MAX_TABLE_NUMBER][MAXFUNCTNUM],
		double *m,double *b,
		double *m_single, double *b_single, 
		int mode, 
		double log_bound,FILE *flog, 
		FILE *fout_coils,
		FILE *fout,  
		int avg_max,
		int main_method, int main_preprocessor_method,
		int main_table);


Changed

      case XK_i:
	if (preprocessor_method == MultiCoil) 
	  preproc_table = (preproc_table +1) % NUMBER_CLASSES;
	else
	  preproc_table = (preproc_table +1) % NUMBER_TABLES;
	ShowSeq(lib,multi_lib,m,b,m_single,b_single,mode,0,2,  bound);
	if (zoomptr) Zoomer();
	break;
      case XK_T:
      case XK_t:
	if (method == MultiCoil) 
	  table = (table +1) % NUMBER_CLASSES;
	else 
	  table = (table +1) % NUMBER_TABLES;
	ShowSeq(lib,multi_lib,m,b,m_single,b_single,mode,0,0, bound);
	if (zoomptr) Zoomer();
	break;


to

      case XK_i:
	if (preprocessor_method == MultiCoil) 
	  preproc_table = (preproc_table +1) % NUMBER_CLASSES;
	else if (preprocessor_method == HMMCoil)
	  preproc_table = (preproc_table +1) % NUMBER_TABLES;
	else preproc_table = 0;
	ShowSeq(lib,multi_lib,m,b,m_single,b_single,mode,0,2,  bound);
	if (zoomptr) Zoomer();
	break;
      case XK_T:
      case XK_t:
	if (method == MultiCoil) 
	  table = (table +1) % NUMBER_CLASSES;
	else if (method == HMMCoil)
	  table = (table +1) % NUMBER_TABLES;
	else table =0;
	ShowSeq(lib,multi_lib,m,b,m_single,b_single,mode,0,0, bound);
	if (zoomptr) Zoomer();
	break;

and changed
      case XK_M:
      case XK_m:
	if (method == MultiCoil) 
	  table = table % NUMBER_CLASSES;
	else if 
	  table = table % NUMBER_TABLES;
	
TO

      case XK_M:
      case XK_m:
	if (method == MultiCoil) 
	  table = table % NUMBER_CLASSES;
	else if (method == HMMCoil)
	  table = table % NUMBER_TABLES;
	else table =0;

and similarly for xk_w

Changed
    get_likelihood_line(likelihoods, m, b, m_single, b_single,
		      lib, pair_functnum,pir_name,mode,NUMBER_TABLES);
to
    get_likelihood_line(likelihoods, m, b, m_single, b_single,
		      lib, pair_functnum,pir_name,mode,1);
since PairCoil doesn't work well for trimer table.