/*------------------------------------------------------------

  Copyright (C) 1999 by Rolf Backofen, Sebastian Will.  
  All Rights Reserved.
  
  Permission to use, copy, modify, and distribute this
  software and its documentation for NON-COMMERCIAL purposes
  and without fee is hereby granted provided that this
  copyright notice appears in all copies.
  
  THE AUTHORS AND PUBLISHER MAKE NO REPRESENTATIONS OR
  WARRANTIES ABOUT THE SUITABILITY OF THE SOFTWARE, EITHER
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHORS
  AND PUBLISHER SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED
  BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  THIS SOFTWARE OR ITS DERIVATIVES.
 ------------------------------------------------------------ */


#include "basicdef.hh"
#include "matrices.hh"
#include "printarray.hh"

// =======================================================================
//
// CLASS:        DistanceMatrix
//
// AUTHOR:       Rolf Backofen <backofen@informatik.uni-muenchen.de>
//
// =======================================================================

// ----------------------------------------------------------------------
// DistanceMatrix construction. a and b are the strings to be aligned
// sets row, col, a,b and initializes darray.
// 
DistanceMatrix::DistanceMatrix(const Sequence &a, const Sequence &b) 
  : matrix<cost_t>(a.length()+1,b.length()+1),a_(a), b_(b)
{
#ifndef NDEBUG
  cout <<"create distance matrix "<<a.length()+1<<" x "<<b.length()+1<<endl;
#endif
}

// ------------------------------------------------------------
// draw to printarray
//
void DistanceMatrix::draw(PrintArray &pr)
{
  char floatstr[PRECISION+1];
  int x,y;
  
  int n = a_.length();
  int m = b_.length();

  /* print b-row, with prefix for a-column   */
  /*                                         */
  for (int j=1; j<=m; ++j)
    {
      x = 2 + j*(PRECISION+ROWFILL) + (PRECISION+ROWFILL-1);
      y = 0;
      pr.set(x,y,b_[j]);
    }

  /* print darray, with a-entry first.       */
  /*                                         */
  for (int i=0; i<=n; ++i) 
    {
      
      y = 1+2*i;

      // a-col
      if (i>0) {
	pr.set(1,y,a_[i]);
      }
      
      // rest
      for (int j=0; j<=m; ++j)
        {
          if ((*this)[i][j] == INFTY)
            floatstr = "   INF";
          else if (MINUSINFTY == (*this)[i][j]) 
            floatstr = "  -INF";
          else
            sprintf(floatstr,"%6.2f",(double)((*this)[i][j]));
          // cout << "|" << floatstr << "|" << endl;
          for (int l=0;l<PRECISION;++l)
            {
              x = 2 + j*(PRECISION+ROWFILL) + (ROWFILL+l);
              if (floatstr[l] != ' ')
                pr.set(x,y,floatstr[l]);
            }
        }
    }
}


// ----------------------------------------------------------------------
// Printing. The darray with the a preceeding row for b_[] and a preceeding 
// column for a_[] is printed. Every value is printed with precision
// PRECISION, and ROWFILL times a ' ' is added between every value.
//
ostream& operator << (ostream &out,DistanceMatrix &mat) {

  char floatstr[PRECISION+1];

  int n = mat.rows()-1;
  int m = mat.cols()-1;
  
  /* print b-row, with prefix for a-column   */
  /*                                         */
  cout << "   ";for (int k=0; k<PRECISION+ROWFILL-1;++k) cout<<' ';
  for (int j=1; j<=m; ++j)
    {
      for (int k=0; k<PRECISION+ROWFILL-1;++k)
        cout << ' ';
      cout << mat.b_[j];
    }
  cout<<endl;

  /* print darray, with a-entry first.       */
  /*                                         */
  for (int i=0; i<=n; ++i, cout<<endl) 
    {
      // a-col
      if (i>0) cout << ' ' << mat.a_[i];
      else     cout << "  ";

      for (int j=0; j<=m; ++j)
        {
          for (int l=0;l<ROWFILL;++l)
            cout << ' ';
          if (mat[i][j] == INFTY)
            floatstr = "   INF";
          else if (MINUSINFTY == mat[i][j])
            floatstr = "  -INF";
          else
            sprintf(floatstr,"%6.2f",(double)(mat[i][j]));
          cout << floatstr;
        }
    }
        
  return out;
}