//   =====================< EXSYMM.CPP >=============================
//   * Examples of MatrixSymm class 				    *
//   * Description: Chapter 12                                      *
//   * Scientific C++ Building Numerical Libraries                  *
//   *                the Object-Oriented Way                       *
//   * by G. Buzzi-Ferraris                                         *
//   * Addison-Wesley (1993)                                        *
//   ****************************************************************
//   * To be linked with: utility.obj, vector.obj, matrix.obj,	    *
//   * left.obj, right.obj,symm.obj				    *
//   ****************************************************************
//   * To execute: exsymm <number> <file name> <Y/N>		    *
//   * If <number> equals zero it executes all examples		    *
//   * otherwise it executes only that example			    *
//   * It writes the results on < file name>			    *
//   * If not used it writes on stdout				    *
//   * If one puts Y/N equal to Y it prints messages as well	    *
//   * The default is Y						    *
//   ****************************************************************
//   * Use:	exsymm 0 pro.doc				    *
//   * Description:	Executes all examples			    *
//   * 	Prints the result on pro.doc			            *
//   * exsymm 1 pro.doc						    *
//   * Executes example 1 with messages and results on PRO.DOC	    *
//   * exsymm							    *
//   * Executes everything and writes it on stdout		    *
//   ================================================================

// Prototype examples
void Ex_MatrixSymm_1(void);
void Ex_MatrixSymm_2(void);
void Ex_MatrixSymm_3(void);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "utility.hpp"
#include "vector.hpp"
#include "matrix.hpp"
#include "left.hpp"
#include "right.hpp"
#include "symm.hpp"

#define NEXMATRIXSYMM 3
#define NMAX NEXMATRIXSYMM+1

main(int argc,char **argv)
{
int i;
void (*ExMatrixSymm[NMAX])(void);
char myfilename[81];

ExMatrixSymm[1]=Ex_MatrixSymm_1;
ExMatrixSymm[2]=Ex_MatrixSymm_2;
ExMatrixSymm[3]=Ex_MatrixSymm_3;

if(argc>=3)
   {
   strcpy(myfilename,argv[2]);

   if((bzzFileOut=fopen(myfilename,"w"))==NULL)
      Error("fopen Failed in EXMATRIXSYMM");
      if(argc==4)bzzYesNo=toupper(argv[3][0]);
   }
else
   {
   bzzFileOut=stdout;
   }

if(argc==1||atoi(argv[1])<=0||atoi(argv[1])>NEXMATRIXSYMM)
   {     /* all examples */
   for(i=1;i<=NEXMATRIXSYMM;i++)
   (*ExMatrixSymm[i])();
   }
else
   {
   (*ExMatrixSymm[atoi(argv[1])])();
   }
return 1;
}

//   ================================================================
//   ====================   EXAMPLES   ==============================
//   ================================================================

//   ===============================================================
//   ===============   INITIALISATIONS   ===========================
//   ===============================================================
void Ex_MatrixSymm_1(void)
{
Message("\n********* MatrixSymm Initialisation ****");
   {
   MatrixSymm A;
	A.Print("MatrixSymm A");
   MatrixSymm B(3,3);
	B.Print("MatrixSymm B(3,3)");
   MatrixSymm C(3,3,1.,2.,3.,4.,5.,6.);
	C.Print("MatrixSymm C(3,3,1.,2.,3.,4.,5.,6.)");
   float w[]={1.,2.,3.,4.,5.,6.};
   MatrixSymm D(3,3,w);
	D.Print("MatrixSymm D(3,3,w)");
   MatrixSymm E=D;
	E.Print("MatrixSymm E=D");
   A=D;
	A.Print("A=D");
   char *fileName="SYMM.DAT";
   MatrixSymm F(fileName);
	F.Print("From File");
   }
Message("\n***** MatrixSymm Assignments ****");
   {
   float w[]={1.,2.,3.,4.,5.,6.};
   MatrixSymm A(3,3,w);
	A.Print("MatrixSymm A(3,3,w)");
   Message("\n2,3=%f 1,2=%f",A.GetValue(2,3),A(1,2));
   A.SetValue(2,3,23.);
   A(1,2)=12.;
	A.Print("2,3=23 1,2=12.");
   }
}

//   ================================================================
//   ==================   OPERATIONS   ==============================
//   ================================================================
void Ex_MatrixSymm_2(void)
{
Message("\n********* MatrixSymm Operators ****");
   {
   float w[]={1.,2.,3.,4.,5.,6.};
   MatrixSymm A(3,3,w),B(3,3,1.,2.,3.,4.,5.,6.),C;
   C=A+B;		C.Print("C=A+B");
   C=A-B;		C.Print("C=A-B");
   }

//   ================================================================
//   ===================   RRT RTR   ================================
//   ================================================================
   {
   Message("\n********** RRT and RTR **************");
   MatrixRight R(3,3,
		 1.,2.,3.,
		     4.,5.,
			 6.);
   MatrixSymm S;
   TProduct(R,&S);
   S.Print("RTR");
   ProductT(R,&S);
   S.Print("RRT");
   }

//   ================================================================
//   ===================   LLT LTL   ================================
//   ================================================================
   {
   Message("\n********** LLT and LTL **************");
   MatrixLeft L(3,3,
		 1.,
		 2.,4.,
		 3.,5.,6.);
   MatrixSymm S;
   TProduct(L,&S);
   S.Print("LTL");
   ProductT(L,&S);
   S.Print("LLT");
   }

}

//   ================================================================
//   ===============   Save and Recover   ===========================
//   ================================================================
void Ex_MatrixSymm_3(void)
{
   {
   Message("\n** WARNING: Recover and Save  uses drive C:\\TEMP **");
   TempFile f1("C:\\TEMP\\");
   MatrixSymm A(3,3,
		 1.,
		 2.,3.,
		 4.,5.,6.);
   A.Print();
   A.Save('*',f1.FileName());
   A(3,3)=100.; // A is modified
   Recover(&A,'*',f1.FileName()); // A is recovered
   MatrixSymm B('*',f1.FileName()); // B is initialised
   B.Print("B");
   A.Print("A");
   MatrixSymm S;
   Recover(&S,'*',f1.FileName());
   S.Print("S");
   }
}