// meine  main.cpp

#include "CRS.h"
#include<fstream>
#include<iostream>

int main(int argc, char** args) 
{   

	double** matrix_A; // Matrix wird deklariert
	int matrix_A_n; 
	// Container werden deklariert

	if(argc!=2) {
		cout << "Bitte Namen der einzulesenden Datei eingeben" << endl;
		return 1;
	}
	//einlesen vom Dateinamen
	infile = string(args[1]); 
	cout << "The determinant of "<<endl;
	// liest Matrix in CRS-Format ein
	read(matrix_A, matrix_A_n, infile, alpha , kappa , rho);
    // gibt die Matrix im CRS_Format aus 
    //print( alpha, kappa, rho); 
	dealloc(matrix_A, matrix_A_n); // Matrix wird gelöscht

	int s;
    cin >> s;

	return 0;
}

// CRS.cpp
/**
 * Übung B 24.01.2010
 * ===============================================
 * 
 * Dieses Programm errechnet Determinanten im CRS-Format
 **/

#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include "CRS.h"

using namespace std;

/**
 * Aufgabenteil 1) Einlesen der Matrix im CRS-Format
 **/

void CRS:: read(double**& mem, int& n, const string& fn, vector<double>&  alpha,vector<double>& kappa, vector<double>& rho) 
{
	double buffer;
	ifstream ifs(fn.c_str());  // liest Textdatei aus dem Stream ein
	if( ifs.is_open() ) {      // öffnet Testdatei
		ifs >> n;              //liest Dimension aus
//		alpha.reserve (n*n);   // reserviert Speicher
//		kappa.reserve ((n)*(n)); 
		alloc(mem, n, n);      // Speicher für Matrix wird reserviert
		for(int i=0;!ifs.eof() && i<n;i++)    // Matrix wird gefüllt
			for(int j=0;!ifs.eof() && j<n;j++) 
				ifs >> mem[i][j];
		ifs.close();           // Stream wird geschlossen
	}
	else {
		cout << "error: the file "<<fn<<" cannot opened for reading."<<endl;
	}
	int position=0;

	// Wandelt die Matrix in CRS Format um
   rho.push_back(0);

    for(int zeile=0; zeile <n; zeile++)
     {   
       for(int spalte=0; spalte< n; spalte++)
       {              
             if( mem[zeile][spalte]!= 0)
                 { alpha.push_back(mem[zeile][spalte]);  // Alpha enthält nicht 0 Elemente der Matrix               
                   kappa.push_back(spalte);              // Kappa speichert die Position der Elemente in der Zeile 

                      position++;
                 }
       }
    rho.push_back(position);                             // rho enthält Zeilenumbrüche    
    }

  print( alpha, kappa, rho);                             //Matrix im CRS_Format wird ausgegeben 
  cout << "is: " << det(n, alpha, kappa , rho) << endl;  // Determinante wird berechnet

}

//Allocation of memory
void CRS::alloc(double**& mem, int m, int n) 
{ 

	mem = new double*[m];
	for(int i=0;i<m;i++) {
		mem[i] = new double[n];
	}
}

// Deallocation of memory
void CRS:: dealloc(double**& mem, const int n) 
{
	if(mem!=NULL) {
		for(int i=0;i<n;i++)
			delete [] mem[i];
		delete [] mem;
		mem=NULL;
	}
}

//Ausgeben der Matrix im CRS-Format
void CRS:: print(vector<double> alpha,vector<double> kappa, vector<double> rho) 
{   
     vector<double>::const_iterator a;

     for (a=alpha.begin();a<alpha.end();a++) cout << *a << " ";
      cout << endl;

     for (a=kappa.begin();a<kappa.end();a++) cout << *a << " ";
      cout << endl;

     for (a=rho.begin();a<rho.end();a++) cout << *a << " ";
      cout << endl;  

      cout <<"" <<endl;      

}

//Erstellen der Untermatrix im CRS-Format
void CRS::create_submatrix(vector<double> alpha,vector<double> kappa, vector<double> rho,
                      vector<double>& sub_alpha,vector<double>& sub_kappa, vector<double>& sub_rho, int knull)
{

  // sub_kappa und sub_alpha berechnen:   
  // da wo kappa 0 ist wird alpha =0 und kappa =-1 gesetzt
  // anschließend werden die Nullen in alpha und die -1'er in kappa gelöscht
for (int i= 0; i<kappa.size(); i++){
    if(kappa.at(i)==0)
    {
     kappa.at(i) =-1;
     alpha.at(i)=0;
    }
 } 

 // zeile zum"löschen" markieren
 if(rho.at(knull+1)== rho.at(rho.size()-1))
 {
  for(int i=knull;i<knull+(alpha.size()-knull-1) ; i++)
         {
              alpha.at(i)=0; 
              kappa.at(i)=-1;             
         }

     }
     else{
           for(int i=knull;i<rho.at(knull+1) ; i++)
           {
              alpha.at(i)=0; 
              kappa.at(i)=-1;             
           }     
         }

 // sub_kappa und sub_alpha füllen
     for(int i= 0; i<alpha.size(); i++)
     {
      if(alpha.at(i)!=0 && kappa.at(i)!=-1)
      {
        sub_alpha.push_back(alpha.at(i)) ;
        sub_kappa.push_back(kappa.at(i)-1) ;                       
      }            
     }         

     //rho bestimmen
    int nullzaehler; //zählt die Nullen in Alpha
    sub_rho.push_back(0);

    for(int i= 1; i<rho.size()-1; i++)
   {       
    if( alpha.at(rho.at(i))!=0 )
    {    
         nullzaehler=0;
         for(int j=0; j<rho.at(i);j++)
         { if(alpha.at(j)==0)
           { 
            nullzaehler++;
           }
          }
         sub_rho.push_back(rho.at(i)-nullzaehler);           
     }

     if(alpha.at(rho.at(i))==0 && rho.at(i)!=rho.at(i+1))
     {   
         nullzaehler=0;
         for(int j=0; j<rho.at(i);j++)
         { if(alpha.at(j)==0)
           { 

            nullzaehler++;
           }
         }
          sub_rho.push_back(rho.at(i)-nullzaehler);          
     }

     }

   /* for( int i=1; i< sub_rho.size(); i++)
          {
              if(sub_rho.at(i)== sub_rho.at(i-1))
              {
                 sub_rho.at(i-1)=-1;
              }  
          } 

     vector<double> subsub_rho;  //temporäres Ausweich-Rho
     subsub_rho=sub_rho;
     sub_rho.clear();            //sub_rho wird geleert
     //es darf keine doppelten Einträge in sub_rho geben(außer möglicherweise am ende, aber
     // das letzte Element wird erst eingefügt, wenn der rest von sub_rho fertig ist)      
     for( int i=0; i< subsub_rho.size(); i++){

           if(subsub_rho.at(i)!=-1)
              {
                 sub_rho.push_back(subsub_rho.at(i)) ;

              }         
          }*/
     sub_rho.push_back(sub_alpha.size());   //Einfügen des letzten Elements in sub_rho, dass angibt,
                                            //wieviele Nicht-Null-Elemente in der Matrix existieren 
   print(sub_alpha, sub_kappa, sub_rho);  //Ausgeben der Untermatrix im CRS-Format 

}

//Methode zur Berechnung der Determinante
double CRS::det( int n,vector<double> alpha,vector<double> kappa,vector<double> rho )
{	
	vector<double> sub_alpha; 
//	sub_alpha.reserve ((n)*(n)); //Speicherreservierung für sub_alpha
    vector<double> sub_kappa;
//   	sub_kappa.reserve ((n)*(n)); 
	vector<double> sub_rho ;

	double d=0.;
	int j=0;
	//Fallunterscheidung für verschiedene Dimensionen
	switch(n) {
		case 0: {
			cerr << "Cannot compute determinant of matrix with dimension 0."<<endl;
			exit(1);
		}
		case 1: {
			d = alpha.at(0);
			break;
		}
		case 2: {
              // 0 oder 1 Element
              cout << "fall 2";
              if(alpha.size()<=1) 
             {
             d=0;
             return d;
             }           

              // 2 Elemente in der Matrix
              if(alpha.size()==2) 
             { 
              // Eine Nullzeile existiert
               if(rho.at(1)==2)// ein Zeilenumbruch und 1mal Anzahl der Elemente
               {
                d=0;   return d;              
               }
                   // Nullspalte
               if(kappa.at(0)==kappa.at(1))
               {
                d=0; return d;
               }
               // 01  zum Beispiel
               // 10
              if(kappa.at(0)==1 && kappa.at(1)!=1)
               {
                d=-alpha.at(0)*alpha.at(1) ;   return d;           
               }
               // 10  zum Beispiel
               // 01
               else{d=alpha.at(0)*alpha.at(1) ; return d;}
             }

            // 3Elemente in der Matrix 
            if(alpha.size() ==3)
            {
                //rho an der 2.Stelle = 1 bedeutet das in der 1.Zeile nur 1 Element steht     
                if( rho.at(1)== 1)
                {  
                        if( kappa.at(0)== 1)
                        {
                         d=-alpha.at(0) * alpha.at(1); return d;
                        }
                        else
                        {
                          d=alpha.at(0) * alpha.at(2); return d;
                        }
                }
                 //rho an der 2.Stelle = 2 bedeutet das in der 2.Zeile nur 1 Element steht
                if( rho.at(1)== 2)
                {
                        if( kappa.at(2)== 1)
                        {
                         d=alpha.at(0) * alpha.at(2); return d;
                        }
                        else
                        {
                          d=-alpha.at(1) * alpha.at(2); return d;
                        }
                }
           } 

        // wenn die 2x2 Matrix voll besetzt ist, dann wird die determinate normal berechnet
             if(rho.at(rho.size()-1) == 4)
             { 	
			   d = alpha.at(0) * alpha.at(3)-alpha.at(1) * alpha.at(2);  return d;		  
              }	
            break;
        }

		default: {

        double res;

		for(int j=0;j<n;j++)
       {  
         res= pow(-1.0,(double)j) ;       

         //Untermatrizen sollen nur dann erstellt werden, wenn der Faktor, also die Zahl mit
         //der die Untermatrix multipliziert wird ungleich Null ist         	
		 if (kappa.at(j)== 0)
         {                 
    	  int knull= j;
    	  create_submatrix(alpha, kappa, rho,sub_alpha, sub_kappa, sub_rho, knull);
    	  res*=alpha.at(j)*det(n-1, sub_alpha, sub_kappa, sub_rho);
          d+=res;      
         }//else{return d=0;}

       }
			break;

	  }

	} 
  //print(sub_alpha, sub_kappa, sub_rho);
	return d;

}

///////////////////////////////////////////////////////////////////////////////

// CRS.h

#include <iostream>
#include <vector>

using namespace std;
class CRS{

public:
CRS::CRS(){}
CRS::~CRS() {}
vector<double> alpha;
vector<double> kappa;
vector<double> rho ;

void read(double**& mem, int& n, const string& fn,vector<double>& alpha,vector<double>& kappa, vector<double>& rho) ;

int main(int argc, char** args) ;
void alloc(double**& mem, int m, int n) ;
void dealloc(double**& mem, const int n) ;

double det(int n,vector<double> alpha,vector<double> kappa,vector<double> rho);
void print(vector<double> alpha,vector<double> kappa, vector<double> rho);
void create_submatrix(vector<double> alpha,vector<double> kappa, vector<double> rho,
vector<double>& sub_alpha,vector<double>& sub_kappa, vector<double>& sub_rho , int knull);

string infile;

};
[cpp]