function r8mat_analyze ( m, n, a, header )

%*****************************************************************************80
%
%% r8mat_analyze() analyzes an R8MAT for linear algebraic properties.
%
%  Discussion:
%
%    An R8MAT is an MxN matrix of real values.
%
%  Licensing:
%
%    This code is distributed under the MIT license.
%
%  Modified:
%
%    17 April 2017
%
%  Author:
%
%    John Burkardt
%
%  Input:
%
%    integer M, N, the row and column dimensions 
%    of the matrix.  M and N must be positive.
%
%    real A(M,N), the matrix.
%
%    string HEADER, a title for the matrix
%
  fprintf ( 1, '\n' );
  fprintf ( 1, 'R8MAT_ANALYZE:\n' );
  fprintf ( 1, '  Report properties of a matrix.\n' );
  fprintf ( 1, '\n' );
  fprintf ( 1, '  Matrix title: "%s"\n', header )
  fprintf ( 1, '  Matrix dimensions (%d,%d)\n', m, n );

  r8mat_print ( m, n, a, header );
  fprintf ( 1, '\n' );
  fprintf ( 1, 'Property      Value        Yes/No        Error norm\n' );
  fprintf ( 1, '--------      -----        ------        ----------\n' );

  ival = r8mat_is_adjacency ( m, n, a );
  fprintf ( 1, 'Adjacency                    ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_anticirculant ( m, n, a );
  fprintf ( 1, 'Anticirculant                ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_antipersymmetric ( m, n, a );
  fprintf ( 1, 'Antipersymmetric error                  %12.2g\n', fnorm );

  fnorm = r8mat_is_antisymmetric ( m, n, a );
  fprintf ( 1, 'Antisymmetric error                     %12.2g\n', fnorm );

  ival = r8mat_is_banded_lower ( m, n, a );
  fprintf ( 1, 'Lower bandwidth                     %4d\n', ival );

  ival = r8mat_is_banded_upper ( m, n, a );
  fprintf ( 1, 'Upper bandwidth                     %4d\n', ival );

  ival = r8mat_is_centrosymmetric ( m, n, a );
  fprintf ( 1, 'Centrosymmetric              ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_circulant ( m, n, a );
  fprintf ( 1, 'Circulant                    ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_cyclic_tridiagonal ( m, n, a );
  fprintf ( 1, 'Cyclic tridiagonal           ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_diag2 ( m, n, a );
  fprintf ( 1, 'Diagonal                                %12.2g\n', fnorm );

  ival = r8mat_is_diagonally_dominant ( n, a );
  fprintf ( 1, 'Diagonally dominant          ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_diagonally_dominant_column ( m, n, a );
  fprintf ( 1, 'Diagonally dominant column   ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_diagonally_dominant_row ( m, n, a );
  fprintf ( 1, 'Diagonally dominant row      ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_hankel ( m, n, a );
  fprintf ( 1, 'Hankel                       ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_identity ( n, a );
  fprintf ( 1, 'Identity error                          %12.2g\n', fnorm );

  fnorm = r8mat_is_integer ( m, n, a );
  fprintf ( 1, 'Integer error                           %12.2g\n', fnorm );

  ival = r8mat_is_irreducible ( m, n, a );
  fprintf ( 1, 'Irreducible                  ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_l ( m, n, a );
  fprintf ( 1, 'L                            ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_m ( m, n, a );
  fprintf ( 1, 'M                            ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_negative ( m, n, a );
  fprintf ( 1, 'Negative                     ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_normal ( m, n, a );
  fprintf ( 1, 'Normal error                            %12.2g\n', fnorm );

  fnorm = r8mat_is_orthogonal ( m, n, a );
  fprintf ( 1, 'Orthogonal error                        %12.2g\n', fnorm );

  fnorm = r8mat_is_orthogonal_column ( m, n, a );
  fprintf ( 1, 'Orthogonal column error                 %12.2g\n', fnorm );

  fnorm = r8mat_is_orthogonal_row ( m, n, a );
  fprintf ( 1, 'Orthogonal row error                    %12.2g\n', fnorm );

  ival = r8mat_is_permutation ( m, n, a );
  fprintf ( 1, 'Permutation                  ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_persymmetric ( m, n, a );
  fprintf ( 1, 'Persymmetric error                      %12.2g\n', fnorm );

  ival = r8mat_is_positive ( m, n, a );
  fprintf ( 1, 'Positive                     ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_propa ( n, a );
  fprintf ( 1, 'Property A                   ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_ref ( m, n, a );
  fprintf ( 1, 'Row Echelon Form             ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end
%
% RREF
%
  ival = r8mat_is_scalar_antidiagonal ( m, n, a );
  fprintf ( 1, 'Constant antidiagonal values ' );
  if ( ~ ival )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_scalar_column ( m, n, a );
  fprintf ( 1, 'Constant column values       ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_scalar_diagonal ( m, n, a );
  fprintf ( 1, 'Constant diagonal values     ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_scalar_row ( m, n, a );
  fprintf ( 1, 'Constant row values          ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_sparse ( m, n, a );
  fprintf ( 1, 'Sparse                                  %12.2g\n', fnorm );

  ival = r8mat_is_spd ( m, n, a );
  fprintf ( 1, 'SPD                          ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  lval = r8mat_is_square ( m, n, a );
  fprintf ( 1, 'Square                       ' );
  if ( ~ lval )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_stochastic ( m, n, a );
  fprintf ( 1, 'Stochastic error                        %12.2g\n', fnorm );
%
%  SUM_BIMARKOV
%  SUM_MAGIC_BIMARKOV
%
  ival = r8mat_is_sum_column ( m, n, a );
  fprintf ( 1, 'Constant column sum          ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_sum_magic ( m, n, a );
  fprintf ( 1, 'Sum magic error                         %12.2g\n', fnorm );

  fnorm = r8mat_is_sum_magic_weak ( m, n, a );
  fprintf ( 1, 'Sum weak magic error                    %12.2g\n', fnorm );

  ival = r8mat_is_sum_row ( m, n, a );
  fprintf ( 1, 'Constant row sum             ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_symmetric ( m, n, a );
  fprintf ( 1, 'Symmetric error                         %12.2g\n', fnorm );

  ival = r8mat_is_toeplitz ( m, n, a );
  fprintf ( 1, 'Toeplitz                     ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_tournament ( n, a );
  fprintf ( 1, 'Tournament error                        %12.2g\n', fnorm );

  fnorm = r8mat_is_transition ( m, n, a );
  fprintf ( 1, 'Transition error                        %12.2g\n', fnorm );

  ival = r8mat_is_triangular_lower ( m, n, a );
  fprintf ( 1, 'Triangular lower             ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_triangular_lower_unit ( m, n, a );
  fprintf ( 1, 'Triangular lower unit        ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_triangular_upper ( m, n, a );
  fprintf ( 1, 'Triangular upper             ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  ival = r8mat_is_triangular_upper_unit ( m, n, a );
  fprintf ( 1, 'Triangular upper unit        ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  fnorm = r8mat_is_unit_column ( m, n, a );
  fprintf ( 1, 'Unit columns error                      %12.2g\n', fnorm );

  fnorm = r8mat_is_unit_row ( m, n, a );
  fprintf ( 1, 'Unit row error                          %12.2g\n', fnorm );

  ival = r8mat_is_zero_one ( m, n, a );
  fprintf ( 1, 'Zero/One                     ' );
  if ( ival < 0 )
    fprintf ( 1, 'No\n' );
  else
    fprintf ( 1, 'Yes\n' );
  end

  return
end
