int main(){
TTableContext Context;
// create scheme
Schema AnimalS;
AnimalS.Add(TPair<TStr,TAttrType>("Animal", atStr));
AnimalS.Add(TPair<TStr,TAttrType>("Size", atStr));
AnimalS.Add(TPair<TStr,TAttrType>("Location", atStr));
AnimalS.Add(TPair<TStr,TAttrType>("Number", atInt));
TIntV RelevantCols;
RelevantCols.Add(0);
RelevantCols.Add(1);
RelevantCols.Add(2);
// create table
PTable T = TTable::LoadSS("Animals", AnimalS, "tests/animals.txt", Context, RelevantCols);
//PTable T = TTable::LoadSS("Animals", AnimalS, "animals.txt");
T->Unique("Animal");
TTable Ts = *T; // did we fix problem with copy-c'tor ?
//PTable Ts = TTable::LoadSS("Animals_s", AnimalS, "../../testfiles/animals.txt", RelevantCols);
//Ts->Unique(AnimalUnique);
// test Select
// create predicate tree: find all animals that are big and african or medium and Australian
TPredicate::TAtomicPredicate A1(atStr, true, EQ, "Location", "", 0, 0, "Africa");
TPredicate::TPredicateNode N1(A1); // Location == "Africa"
TPredicate::TAtomicPredicate A2(atStr, true, EQ, "Size", "", 0, 0, "big");
TPredicate::TPredicateNode N2(A2); // Size == "big"
TPredicate::TPredicateNode N3(AND);
N3.AddLeftChild(&N1);
N3.AddRightChild(&N2);
TPredicate::TAtomicPredicate A4(atStr, true, EQ, "Location", "", 0, 0, "Australia");
TPredicate::TPredicateNode N4(A4);
TPredicate::TAtomicPredicate A5(atStr, true, EQ, "Size", "", 0, 0, "medium");
TPredicate::TPredicateNode N5(A5);
TPredicate::TPredicateNode N6(AND);
N6.AddLeftChild(&N4);
N6.AddRightChild(&N5);
TPredicate::TPredicateNode N7(OR);
N7.AddLeftChild(&N3);
N7.AddRightChild(&N6);
TPredicate Pred(&N7);
TIntV SelectedRows;
Ts.Select(Pred, SelectedRows);
TStrV GroupBy;
GroupBy.Add("Location");
T->Group(GroupBy, "LocationGroup");
GroupBy.Add("Size");
T->Group(GroupBy, "LocationSizeGroup");
T->Count("LocationCount", "Location");
PTable Tj = T->Join("Location", Ts, "Location");
TStrV UniqueAnimals;
UniqueAnimals.Add("Animals_1.Animal");
UniqueAnimals.Add("Animals_2.Animal");
Tj->Unique(UniqueAnimals, false);
//print table
T->SaveSS("tests/animals_out_T.txt");
Ts.SaveSS("tests/animals_out_Ts.txt");
Tj->SaveSS("tests/animals_out_Tj.txt");
return 0;
}
std::string makeFormattedString(
const char* aFormat,
const A1& a1 = A1(),
const A2& a2 = A2(),
const A3& a3 = A3(),
const A4& a4 = A4(),
const A5& a5 = A5(),
const A6& a6 = A6(),
const A7& a7 = A7(),
const A8& a8 = A8(),
const A9& a9 = A9(),
const A10& a10 = A10(),
const A11& a11 = A11(),
const A12& a12 = A12(),
const A13& a13 = A13(),
const A14& a14 = A14(),
const A15& a15 = A15(),
const A16& a16 = A16(),
const A17& a17 = A17(),
const A18& a18 = A18(),
const A19& a19 = A19(),
const A20& a20 = A20()
)
{
return makeStringByPrintf(aFormat,
a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20
);
}
int main(void)
{
A4();
printf("\n\n\nProgramm Ende! Enter Druecken...");
fflush(stdin);
getc(stdin);
return 0;
}
int hpx_main(boost::program_options::variables_map& vm)
{
{
orthotope<double>
A0({3, 3})
, A1({3, 3})
, A2({3, 3})
, A3({3, 3})
, A4({3, 3})
, A5({4, 4})
;
// QR {{1, 3, 6}, {3, 5, 7}, {6, 7, 4}}
A0.row(0, 1, 3, 6 );
A0.row(1, 3, 5, 7 );
A0.row(2, 6, 7, 4 );
// QR {{12, -51, 4}, {6, 167, -68}, {-4, 24, -41}}
A1.row(0, 12, -51, 4 );
A1.row(1, 6, 167, -68 );
A1.row(2, -4, 24, -41 );
// QR {{2, -2, 18}, {2, 1, 0}, {1, 2, 0}}
A2.row(0, 2, -2, 18 );
A2.row(1, 2, 1, 0 );
A2.row(2, 1, 2, 0 );
// QR {{0, 1, 1}, {1, 1, 2}, {0, 0, 3}}
A3.row(0, 0, 1, 1 );
A3.row(1, 1, 1, 2 );
A3.row(2, 0, 0, 3 );
// QR {{1, 1, -1}, {1, 2, 1}, {1, 2, -1}}
A4.row(0, 1, 1, -1 );
A4.row(1, 1, 2, 1 );
A4.row(2, 1, 2, -1 );
// QR {{4, -2, 2, 8}, {-2, 6, 2, 4}, {2, 2, 10, -6}, {8, 4, -6, 12}}
A5.row(0, 4, -2, 2, 8 );
A5.row(1, -2, 6, 2, 4 );
A5.row(2, 2, 2, 10, -6 );
A5.row(3, 8, 4, -6, 12 );
householders(A0);
householders(A1);
householders(A2);
householders(A3);
householders(A4);
householders(A5);
}
return hpx::finalize();
}
Array4d Analysis::getNumberDensity(const bool total) {
for(int s = NsLlD; s <= NsLuD; s++) {
const double d6Z = scaleXYZV * plasma->B0 * M_PI;
for(int x=NxLlD; x<= NxLuD;x++) { for(int y=NkyLlD; y<= NkyLuD;y++) { for(int z=NzLlD; z<= NzLuD;z++){
A4(x,y,z,s) = abs(F(x, y, z, RvLD, RmLD, s))*d6Z;
}}} }
return parallel->collect(A4, OP_SUM, DIR_VM);
};
TypeOfFE_Lagrange(int k):
// dfon ,N,nsub(graphique) , const mat interpolation , discontinuous
GTypeOfFE<Mesh>(A4(k),1,k==-1?-1:Max(k,1),k<=2,k==0)
{
int n=this->NbDoF;
if(verbosity>9)
cout << "\n +++ P"<<k<<" : ndof : "<< n <<endl;
SetPtPk<RdHat,Element> (this->PtInterpolation,this->ndfOn(),this->NbDoF);
if(verbosity>9) cout << this->PtInterpolation<< endl;
for (int i=0;i<n;i++)
{
this->pInterpolation[i]=i;
this->cInterpolation[i]=0;
this->dofInterpolation[i]=i;
this->coefInterpolation[i]=1.;
}
}
int main()
{
int n = 0, a1 = 0, a2 = 0, a3 = 0, a4 = 0, a5 = 0, num = 0;
int count_a1 = 0, count_a2 = 0, count_a3 = 0, count_a4 = 0, count_a5 = 0;
int flag_A2 = 1;
scanf("%d", &n);
for (; n > 0; n--) {
scanf("%d", &num);
A1(num, &a1, &count_a1);
A2(num, &a2, &count_a2, &flag_A2);
A3(num, &a3, &count_a3);
A4(num, &a4, &count_a4);
A5(num, &a5, &count_a5);
}
if (count_a1 > 0)
printf("%d ", a1);
else
printf("N ");
if (count_a2 > 0)
printf("%d ", a2);
else
printf("N ");
if (count_a3 > 0)
printf("%d ", a3);
else
printf("N ");
if (count_a4 > 0)
printf("%.1lf ", (double)a4 / count_a4);
else
printf("N ");
if (count_a5 > 0)
printf("%d", a5);
else
printf("N");
return 0;
}
int test()
{
int Error(0);
{
float A0(3.0);
float B0(2.0f);
float C0 = glm::fmod(A0, B0);
Error += glm::abs(C0 - 1.0f) < 0.00001f ? 0 : 1;
glm::vec4 A1(3.0);
float B1(2.0f);
glm::vec4 C1 = glm::fmod(A1, B1);
Error += glm::all(glm::epsilonEqual(C1, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
glm::vec4 A2(3.0);
glm::vec4 B2(2.0f);
glm::vec4 C2 = glm::fmod(A2, B2);
Error += glm::all(glm::epsilonEqual(C2, glm::vec4(1.0f), 0.00001f)) ? 0 : 1;
glm::ivec4 A3(3);
int B3(2);
glm::ivec4 C3 = glm::fmod(A3, B3);
Error += glm::all(glm::equal(C3, glm::ivec4(1))) ? 0 : 1;
glm::ivec4 A4(3);
glm::ivec4 B4(2);
glm::ivec4 C4 = glm::fmod(A4, B4);
Error += glm::all(glm::equal(C4, glm::ivec4(1))) ? 0 : 1;
}
{
float A0(22.0);
float B0(-10.0f);
float C0 = glm::fmod(A0, B0);
Error += glm::abs(C0 - 2.0f) < 0.00001f ? 0 : 1;
glm::vec4 A1(22.0);
float B1(-10.0f);
glm::vec4 C1 = glm::fmod(A1, B1);
Error += glm::all(glm::epsilonEqual(C1, glm::vec4(2.0f), 0.00001f)) ? 0 : 1;
glm::vec4 A2(22.0);
glm::vec4 B2(-10.0f);
glm::vec4 C2 = glm::fmod(A2, B2);
Error += glm::all(glm::epsilonEqual(C2, glm::vec4(2.0f), 0.00001f)) ? 0 : 1;
glm::ivec4 A3(22);
int B3(-10);
glm::ivec4 C3 = glm::fmod(A3, B3);
Error += glm::all(glm::equal(C3, glm::ivec4(2))) ? 0 : 1;
glm::ivec4 A4(22);
glm::ivec4 B4(-10);
glm::ivec4 C4 = glm::fmod(A4, B4);
Error += glm::all(glm::equal(C4, glm::ivec4(2))) ? 0 : 1;
}
// http://stackoverflow.com/questions/7610631/glsl-mod-vs-hlsl-fmod
{
for (float y = -10.0f; y < 10.0f; y += 0.1f)
for (float x = -10.0f; x < 10.0f; x += 0.1f)
{
float const A(std::fmod(x, y));
//float const B(std::remainder(x, y));
float const C(glm::fmod(x, y));
float const D(modTrunc(x, y));
//Error += glm::epsilonEqual(A, B, 0.0001f) ? 0 : 1;
//assert(!Error);
Error += glm::epsilonEqual(A, C, 0.0001f) ? 0 : 1;
assert(!Error);
Error += glm::epsilonEqual(A, D, 0.00001f) ? 0 : 1;
assert(!Error);
}
}
return Error;
}
int main(int argc, char** argv) {
const int TARIFFA = 2;
Autovettura A1("bj066mx", "benzina", "suv", 6);
Autovettura A2("kt887gg", "gpl", "monovolume", 5);
Autovettura A3("dh572xc", "metano", "berlina", 5);
Autovettura A4("mq111nd", "diesel", "utilitaria", 4);
Autobus A5("cc789oi", "benzina", "bus", 50, "Milano", 200);
Autobus A6("st230ks", "gpl", "bus", 50, "Roma", 300);
Autobus A7("vv234sd", "metano", "bus", 25, "Napoli", 100);
Autobus A8("we785ss", "diesel", "bus", 60, "Parma", 400);
Autoveicolo * v[8];
v[0] = &A1;
v[1] = &A2;
v[2] = &A3;
v[3] = &A4;
v[4] = &A5;
v[5] = &A6;
v[6] = &A7;
v[7] = &A8;
cout<<"Polimorfismo:\n";
for(int i=0; i<8; i++) {
v[i]->stampaDati();
cout << "\n";
}
Coda C1, C2, C3;
C1.append(&A1);
C1.append(&A2);
C1.append(&A3);
C1.append(&A4);
C1.append(&A5);
C1.append(&A6);
C1.append(&A7);
C1.append(&A8);
C2.append(&A1);
C2.append(&A2);
C2.append(&A3);
C2.append(&A4);
C2.append(&A5);
C2.append(&A6);
C2.append(&A7);
C3.append(&A1);
C3.append(&A2);
C3.append(&A3);
C3.append(&A4);
C3.append(&A5);
C3.append(&A6);
cout<<"\n\n\nCoda1:\n";
cout<<C1;
cout<<"\n\n\nCoda2:\n";
cout<<C2;
cout<<"\n\n\nCoda3:\n";
cout<<C3;
cout<<"\n\n\n";
int e1, e2, e3;
e1 = C1.getNelem();
e2 = C2.getNelem();
e3 = C3.getNelem();
for(int i = 0; i<e1; i++) {
Autoveicolo * elem;
C1.pop(elem, TARIFFA);
cout<<"Elemento rimosso -> ";
elem->stampaDati();
cout<<endl;
}
cout<<"\n\n\n";
for(int i = 0; i<e2; i++) {
Autoveicolo * elem;
C2.pop(elem, TARIFFA);
cout<<"Elemento rimosso -> ";
elem->stampaDati();
cout<<endl;
}
cout<<"\n\n\n";
for(int i = 0; i<e3; i++) {
Autoveicolo * elem;
C3.pop(elem, TARIFFA);
cout<<"Elemento rimosso -> ";
elem->stampaDati();
cout<<endl;
}
if(C1.getIncasso()>100) {
cout<<"\n\n\nIncasso totale: "<<C1.getIncasso()<< " bombe!";
} else {
cout<<"\n\n\nIncasso totale: "<<C1.getIncasso()<<" frecce!";
}
return 0;
}
int main(void){
Marray<double,4> A4(3,3,3,3);
Marray<double,1> B1(3);
Marray<double,3> C3Test(3,3,3);
Marray<double,3> C3(3,3,3);
A4.sucesion(0,1);
B1.sucesion(0,1);
Index<'i'> iG;
Index<'j'> jG;
Index<'k'> kG;
Index<'l'> lG;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(i,j,k,l)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(iG,jG,kG,lG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(i,j,l,k)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(iG,jG,lG,kG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(i,l,j,k)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(iG,lG,jG,kG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(j,i,k,l)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(jG,iG,kG,lG)*B1(lG);
assert(C3==C3Test);
C3=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for(int k=0;k<3;k++){
C3(i,j,k)+=A4(l,i,j,k)*B1(l);
}
}
}
}
C3Test(iG,jG,kG)=A4(lG,iG,jG,kG)*B1(lG);
assert(C3==C3Test);
C3=0;
}
blit(muertebmp,enemigom,0,0,0,0,33,33);//carga la imagen sobre el buffer pacman
draw_sprite(buffer,enemigom,_x,_y);
blit(buffer, screen ,0,0,0,0,1280,600);
rest(80);
_x = 0;
_y = 0;
vidaenemigo--;
}
}
int main()
{
allegro_init();
install_keyboard();
set_color_depth(32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED,1280, 600 , 0, 0);
//inicializa la musica en allegro
if (install_sound(DIGI_AUTODETECT, MIDI_AUTODETECT, NULL) != 0)
{
allegro_message("Error: inicializando sistema de sonido\n%s\n", allegro_error);
return 1;
}
// ajuste de volumen
set_volume(70, 70);//cuanto se oye a la izquierdsa y a la derecha
intro = load_wav("music/start.wav");
sirenafantasma = load_wav("music/sirene.wav");
muertes = load_wav("music/muerte.wav");
buffer = create_bitmap(1280,600); //870 570
pacman = create_bitmap(33,33);
complemento = create_bitmap(400,600);
vid =create_bitmap(33,33);
ataqueb = create_bitmap(33,33);
atabmp = load_bitmap("images/ataque.bmp",NULL);
roca = load_bitmap("images/tile2.bmp",NULL);
pacbmp =load_bitmap("images/tank2.bmp", NULL);
comida = load_bitmap("images/Comida.bmp",NULL);
muertebmp = load_bitmap("images/muerte1.bmp",NULL);
combmp =load_bitmap("images/complemento.bmp",NULL);
vidas = load_bitmap("images/vidas.bmp",NULL);
mapa1 mapa;
enemigo A1(30*1,30*18) ;
enemigo A2(30*27,30*1) ;
enemigo A3(30*14,30*11) ;
enemigo A4(30*27,30*18) ;
enemigo A5(30*27,30*18);
personaje1 personaje;
personaje2 personaje3;
play_sample(intro,200,150,1000,0); // volumen,sonido,,velocidad a la que se reproduce,distribucion 1000 es punto medio,para que no se repita
rest(4000);
play_sample(sirenafantasma,150,150,1000,1);
while (!key[KEY_ESC] && mapa.game_over())
{
if(A1.getvida()==0 && A2.getvida()==0 && A3.getvida()==0 && A4.getvida()==0) return false;
personaje.mover_personaje();
mapa.dibujar_mapa();
personaje.dibujar_personaje();
personaje.ataque();
personaje.ataque1();
personaje3.dibujar_personaje();
personaje3.mover_personaje();
A1.mover_enemigo();
A2.mover_enemigo();
A4.mover_enemigo();
A3.mover_enemigo();
personaje3.ataque();
personaje3.ataque1();
A1.ataque2();
A1.ataque_enemigo();
A2.ataque2();
A2.ataque_enemigo();
A4.ataque2();
A4.ataque_enemigo();
A3.ataque2();
A3.ataque_enemigo();
A1.muerte_enemigo();
A2.muerte_enemigo();
SolidesP ConstruireNormale (FacesP Face)
// Construit un solide symbolisant la normale à la face.
// Le solide est placé sur le barycentre de la face et peut donc
// être hors de la face.
// Sa longueur est égale à 5% de la dimension du solide à laquelle la
// face appartient s'il existe. Sinon, c'est 10 % de la dimension de la face.
{
SolidesP Sol = Face.Solide () ;
double HauteurTot ;
Englobants3D EnglobantFace = Face.Englobant () ;
if (Sol.EstInitialise ()) {
Englobants3D E = Sol.Englobant () ;
Vecteurs3D V (E.BasGauche (),E.HautDroit ()) ;
HauteurTot = 0.05*V.Norme () ; ;
}
else {
Vecteurs3D V (EnglobantFace.BasGauche (),EnglobantFace.HautDroit ()) ;
HauteurTot = 0.1*V.Norme () ; ;
}
double LargeurPied = HauteurTot / 24,
LargeurTete = HauteurTot / 4,
HauteurPied = (7./8.)*HauteurTot ;
// Construction d'un repère centré sur le "barycentre" de la face, dont
// le (xOy) correspond au plan de la face et dont le z est la normale Ã
// la face.
Points3D Origine = 0.5*(EnglobantFace.BasGauche ()+EnglobantFace.HautDroit ()) ;
Vecteurs3D K = Face.VecteurNormal ().VecteurNorme (),
U (Face.ContourExterieur ().IemeAreteOrientee (0).Origine ().Point3D (),
Face.ContourExterieur ().IemeAreteOrientee (0).Extremite ().Point3D ()),
I = (K & U).VecteurNorme (),
J = (K & I).VecteurNorme () ;
SommetsP S1 (Origine-LargeurPied/2*I - LargeurPied/2*J) ;
SommetsP S2 (Origine-LargeurPied/2*I + LargeurPied/2*J) ;
SommetsP S3 (Origine+LargeurPied/2*I + LargeurPied/2*J) ;
SommetsP S4 (Origine+LargeurPied/2*I - LargeurPied/2*J) ;
SommetsP S5 (Origine-LargeurPied/2*I - LargeurPied/2*J + HauteurPied*K) ;
SommetsP S6 (Origine-LargeurPied/2*I + LargeurPied/2*J + HauteurPied*K) ;
SommetsP S7 (Origine+LargeurPied/2*I + LargeurPied/2*J + HauteurPied*K) ;
SommetsP S8 (Origine+LargeurPied/2*I - LargeurPied/2*J + HauteurPied*K) ;
SommetsP S9 (Origine-LargeurTete/2*I - LargeurTete/2*J + HauteurPied*K) ;
SommetsP S10 (Origine-LargeurTete/2*I + LargeurTete/2*J + HauteurPied*K) ;
SommetsP S11 (Origine+LargeurTete/2*I + LargeurTete/2*J + HauteurPied*K) ;
SommetsP S12 (Origine+LargeurTete/2*I - LargeurTete/2*J + HauteurPied*K) ;
SommetsP S13 (Origine+HauteurTot*K) ;
AretesP A1 (S1,S2) ;
AretesP A2 (S2,S3) ;
AretesP A3 (S3,S4) ;
AretesP A4 (S4,S1) ;
AretesP A5 (S5,S6) ;
AretesP A6 (S6,S7) ;
AretesP A7 (S7,S8) ;
AretesP A8 (S8,S5) ;
AretesP A9 (S9,S10) ;
AretesP A10 (S10,S11) ;
AretesP A11 (S11,S12) ;
AretesP A12 (S12,S9) ;
AretesP A13 (S1,S5) ;
AretesP A14 (S2,S6) ;
AretesP A15 (S3,S7) ;
AretesP A16 (S4,S8) ;
AretesP A17 (S9,S13) ;
AretesP A18 (S10,S13) ;
AretesP A19 (S11,S13) ;
AretesP A20 (S12,S13) ;
Listes <AretesP> L1 ;
L1.InsertionEnQueue (A1) ;
L1.InsertionEnQueue (A2) ;
L1.InsertionEnQueue (A3) ;
L1.InsertionEnQueue (A4) ;
Listes <AretesP> L2 ;
L2.InsertionEnQueue (A1) ;
L2.InsertionEnQueue (A13) ;
L2.InsertionEnQueue (A5) ;
L2.InsertionEnQueue (A14) ;
Listes <AretesP> L3 ;
L3.InsertionEnQueue (A2) ;
L3.InsertionEnQueue (A14) ;
L3.InsertionEnQueue (A6) ;
L3.InsertionEnQueue (A15) ;
Listes <AretesP> L4 ;
L4.InsertionEnQueue (A3) ;
L4.InsertionEnQueue (A15) ;
L4.InsertionEnQueue (A7) ;
L4.InsertionEnQueue (A16) ;
Listes <AretesP> L5 ;
L5.InsertionEnQueue (A4) ;
L5.InsertionEnQueue (A16) ;
L5.InsertionEnQueue (A8) ;
L5.InsertionEnQueue (A13) ;
Listes <AretesP> L6 ;
L6.InsertionEnQueue (A9) ;
L6.InsertionEnQueue (A10) ;
L6.InsertionEnQueue (A11) ;
L6.InsertionEnQueue (A12) ;
Listes <AretesP> L7 ;
L7.InsertionEnQueue (A8) ;
L7.InsertionEnQueue (A7) ;
L7.InsertionEnQueue (A6) ;
L7.InsertionEnQueue (A5) ;
Listes <AretesP> L8 ;
L8.InsertionEnQueue (A9) ;
L8.InsertionEnQueue (A17) ;
L8.InsertionEnQueue (A18) ;
Listes <AretesP> L9 ;
L9.InsertionEnQueue (A10) ;
L9.InsertionEnQueue (A18) ;
L9.InsertionEnQueue (A19) ;
Listes <AretesP> L10 ;
L10.InsertionEnQueue (A11) ;
L10.InsertionEnQueue (A19) ;
L10.InsertionEnQueue (A20) ;
Listes <AretesP> L11 ;
L11.InsertionEnQueue (A12) ;
L11.InsertionEnQueue (A20) ;
L11.InsertionEnQueue (A17) ;
Listes <FacesP> ListeFaces ;
AttributsFaces *PAF = new AttributsFaces (PMateriauRouge) ;
FacesP F1 (ContoursP (L1),PAF) ;
ListeFaces.InsertionEnQueue (F1) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L2),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L3),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L4),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L5),PAF)) ;
ContoursP C (L6) ;
FacesP F (C,PAF) ;
F.AjouterContourInterieur (ContoursP (L7)) ;
ListeFaces.InsertionEnQueue (F) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L8),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L9),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L10),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L11),PAF)) ;
return SolidesP (ListeFaces) ;
}
int main(int argc, char *argv[])
{
int ierr = 0, forierr = 0;
bool debug = false;
#ifdef EPETRA_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
int rank; // My process ID
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
int rank = 0;
Epetra_SerialComm Comm;
#endif
bool verbose = false;
// Check if we should print results to standard out
if (argc>1) if (argv[1][0]=='-' && argv[1][1]=='v') verbose = true;
int verbose_int = verbose ? 1 : 0;
Comm.Broadcast(&verbose_int, 1, 0);
verbose = verbose_int==1 ? true : false;
// char tmp;
// if (rank==0) cout << "Press any key to continue..."<< std::endl;
// if (rank==0) cin >> tmp;
// Comm.Barrier();
Comm.SetTracebackMode(0); // This should shut down any error traceback reporting
int MyPID = Comm.MyPID();
int NumProc = Comm.NumProc();
if(verbose && MyPID==0)
cout << Epetra_Version() << std::endl << std::endl;
if (verbose) cout << "Processor "<<MyPID<<" of "<< NumProc
<< " is alive."<<endl;
bool verbose1 = verbose;
// Redefine verbose to only print on PE 0
if(verbose && rank!=0)
verbose = false;
int NumMyEquations = 10000;
int NumGlobalEquations = (NumMyEquations * NumProc) + EPETRA_MIN(NumProc,3);
if(MyPID < 3)
NumMyEquations++;
// Construct a Map that puts approximately the same Number of equations on each processor
Epetra_Map Map(NumGlobalEquations, NumMyEquations, 0, Comm);
// Get update list and number of local equations from newly created Map
int* MyGlobalElements = new int[Map.NumMyElements()];
Map.MyGlobalElements(MyGlobalElements);
// Create an integer vector NumNz that is used to build the Petra Matrix.
// NumNz[i] is the Number of OFF-DIAGONAL term for the ith global equation on this processor
int* NumNz = new int[NumMyEquations];
// We are building a tridiagonal matrix where each row has (-1 2 -1)
// So we need 2 off-diagonal terms (except for the first and last equation)
for (int i = 0; i < NumMyEquations; i++)
if((MyGlobalElements[i] == 0) || (MyGlobalElements[i] == NumGlobalEquations - 1))
NumNz[i] = 1;
else
NumNz[i] = 2;
// Create a Epetra_Matrix
Epetra_CrsMatrix A(Copy, Map, NumNz);
EPETRA_TEST_ERR(A.IndicesAreGlobal(),ierr);
EPETRA_TEST_ERR(A.IndicesAreLocal(),ierr);
// Add rows one-at-a-time
// Need some vectors to help
// Off diagonal Values will always be -1
double* Values = new double[2];
Values[0] = -1.0;
Values[1] = -1.0;
int* Indices = new int[2];
double two = 2.0;
int NumEntries;
forierr = 0;
for (int i = 0; i < NumMyEquations; i++) {
if(MyGlobalElements[i] == 0) {
Indices[0] = 1;
NumEntries = 1;
}
else if (MyGlobalElements[i] == NumGlobalEquations-1) {
Indices[0] = NumGlobalEquations-2;
NumEntries = 1;
}
else {
Indices[0] = MyGlobalElements[i]-1;
Indices[1] = MyGlobalElements[i]+1;
NumEntries = 2;
}
forierr += !(A.InsertGlobalValues(MyGlobalElements[i], NumEntries, Values, Indices)==0);
forierr += !(A.InsertGlobalValues(MyGlobalElements[i], 1, &two, MyGlobalElements+i)>0); // Put in the diagonal entry
}
EPETRA_TEST_ERR(forierr,ierr);
int * indexOffsetTmp;
int * indicesTmp;
double * valuesTmp;
// Finish up
EPETRA_TEST_ERR(!(A.IndicesAreGlobal()),ierr);
EPETRA_TEST_ERR(!(A.ExtractCrsDataPointers(indexOffsetTmp, indicesTmp, valuesTmp)==-1),ierr); // Should fail
EPETRA_TEST_ERR(!(A.FillComplete(false)==0),ierr);
EPETRA_TEST_ERR(!(A.ExtractCrsDataPointers(indexOffsetTmp, indicesTmp, valuesTmp)==-1),ierr); // Should fail
EPETRA_TEST_ERR(!(A.IndicesAreLocal()),ierr);
EPETRA_TEST_ERR(A.StorageOptimized(),ierr);
A.OptimizeStorage();
EPETRA_TEST_ERR(!(A.StorageOptimized()),ierr);
EPETRA_TEST_ERR(!(A.ExtractCrsDataPointers(indexOffsetTmp, indicesTmp, valuesTmp)==0),ierr); // Should succeed
const Epetra_CrsGraph & GofA = A.Graph();
EPETRA_TEST_ERR((indicesTmp!=GofA[0] || valuesTmp!=A[0]),ierr); // Extra check to see if operator[] is consistent
EPETRA_TEST_ERR(A.UpperTriangular(),ierr);
EPETRA_TEST_ERR(A.LowerTriangular(),ierr);
int NumMyNonzeros = 3 * NumMyEquations;
if(A.LRID(0) >= 0)
NumMyNonzeros--; // If I own first global row, then there is one less nonzero
if(A.LRID(NumGlobalEquations-1) >= 0)
NumMyNonzeros--; // If I own last global row, then there is one less nonzero
EPETRA_TEST_ERR(check(A, NumMyEquations, NumGlobalEquations, NumMyNonzeros, 3*NumGlobalEquations-2,
MyGlobalElements, verbose),ierr);
forierr = 0;
for (int i = 0; i < NumMyEquations; i++)
forierr += !(A.NumGlobalEntries(MyGlobalElements[i])==NumNz[i]+1);
EPETRA_TEST_ERR(forierr,ierr);
forierr = 0;
for (int i = 0; i < NumMyEquations; i++)
forierr += !(A.NumMyEntries(i)==NumNz[i]+1);
EPETRA_TEST_ERR(forierr,ierr);
if (verbose) cout << "\n\nNumEntries function check OK" << std::endl<< std::endl;
EPETRA_TEST_ERR(check_graph_sharing(Comm),ierr);
// Create vectors for Power method
Epetra_Vector q(Map);
Epetra_Vector z(Map);
Epetra_Vector resid(Map);
// variable needed for iteration
double lambda = 0.0;
// int niters = 10000;
int niters = 200;
double tolerance = 1.0e-1;
/////////////////////////////////////////////////////////////////////////////////////////////////
// Iterate
Epetra_Flops flopcounter;
A.SetFlopCounter(flopcounter);
q.SetFlopCounter(A);
z.SetFlopCounter(A);
resid.SetFlopCounter(A);
Epetra_Time timer(Comm);
EPETRA_TEST_ERR(power_method(false, A, q, z, resid, &lambda, niters, tolerance, verbose),ierr);
double elapsed_time = timer.ElapsedTime();
double total_flops = A.Flops() + q.Flops() + z.Flops() + resid.Flops();
double MFLOPs = total_flops/elapsed_time/1000000.0;
if (verbose) cout << "\n\nTotal MFLOPs for first solve = " << MFLOPs << std::endl<< std::endl;
/////////////////////////////////////////////////////////////////////////////////////////////////
// Solve transpose problem
if (verbose) cout << "\n\nUsing transpose of matrix and solving again (should give same result).\n\n"
<< std::endl;
// Iterate
lambda = 0.0;
flopcounter.ResetFlops();
timer.ResetStartTime();
EPETRA_TEST_ERR(power_method(true, A, q, z, resid, &lambda, niters, tolerance, verbose),ierr);
elapsed_time = timer.ElapsedTime();
total_flops = A.Flops() + q.Flops() + z.Flops() + resid.Flops();
MFLOPs = total_flops/elapsed_time/1000000.0;
if (verbose) cout << "\n\nTotal MFLOPs for transpose solve = " << MFLOPs << std::endl<< endl;
/////////////////////////////////////////////////////////////////////////////////////////////////
// Increase diagonal dominance
if (verbose) cout << "\n\nIncreasing the magnitude of first diagonal term and solving again\n\n"
<< endl;
if (A.MyGlobalRow(0)) {
int numvals = A.NumGlobalEntries(0);
double * Rowvals = new double [numvals];
int * Rowinds = new int [numvals];
A.ExtractGlobalRowCopy(0, numvals, numvals, Rowvals, Rowinds); // Get A[0,0]
for (int i=0; i<numvals; i++) if (Rowinds[i] == 0) Rowvals[i] *= 10.0;
A.ReplaceGlobalValues(0, numvals, Rowvals, Rowinds);
delete [] Rowvals;
delete [] Rowinds;
}
// Iterate (again)
lambda = 0.0;
flopcounter.ResetFlops();
timer.ResetStartTime();
EPETRA_TEST_ERR(power_method(false, A, q, z, resid, &lambda, niters, tolerance, verbose),ierr);
elapsed_time = timer.ElapsedTime();
total_flops = A.Flops() + q.Flops() + z.Flops() + resid.Flops();
MFLOPs = total_flops/elapsed_time/1000000.0;
if (verbose) cout << "\n\nTotal MFLOPs for second solve = " << MFLOPs << endl<< endl;
/////////////////////////////////////////////////////////////////////////////////////////////////
// Solve transpose problem
if (verbose) cout << "\n\nUsing transpose of matrix and solving again (should give same result).\n\n"
<< endl;
// Iterate (again)
lambda = 0.0;
flopcounter.ResetFlops();
timer.ResetStartTime();
EPETRA_TEST_ERR(power_method(true, A, q, z, resid, &lambda, niters, tolerance, verbose),ierr);
elapsed_time = timer.ElapsedTime();
total_flops = A.Flops() + q.Flops() + z.Flops() + resid.Flops();
MFLOPs = total_flops/elapsed_time/1000000.0;
if (verbose) cout << "\n\nTotal MFLOPs for tranpose of second solve = " << MFLOPs << endl<< endl;
if (verbose) cout << "\n\n*****Testing constant entry constructor" << endl<< endl;
Epetra_CrsMatrix AA(Copy, Map, 5);
if (debug) Comm.Barrier();
double dble_one = 1.0;
for (int i=0; i< NumMyEquations; i++) AA.InsertGlobalValues(MyGlobalElements[i], 1, &dble_one, MyGlobalElements+i);
// Note: All processors will call the following Insert routines, but only the processor
// that owns it will actually do anything
int One = 1;
if (AA.MyGlobalRow(0)) {
EPETRA_TEST_ERR(!(AA.InsertGlobalValues(0, 0, &dble_one, &One)==0),ierr);
}
else EPETRA_TEST_ERR(!(AA.InsertGlobalValues(0, 1, &dble_one, &One)==-1),ierr);
EPETRA_TEST_ERR(!(AA.FillComplete(false)==0),ierr);
EPETRA_TEST_ERR(AA.StorageOptimized(),ierr);
EPETRA_TEST_ERR(!(AA.UpperTriangular()),ierr);
EPETRA_TEST_ERR(!(AA.LowerTriangular()),ierr);
if (debug) Comm.Barrier();
EPETRA_TEST_ERR(check(AA, NumMyEquations, NumGlobalEquations, NumMyEquations, NumGlobalEquations,
MyGlobalElements, verbose),ierr);
if (debug) Comm.Barrier();
forierr = 0;
for (int i=0; i<NumMyEquations; i++) forierr += !(AA.NumGlobalEntries(MyGlobalElements[i])==1);
EPETRA_TEST_ERR(forierr,ierr);
if (verbose) cout << "\n\nNumEntries function check OK" << endl<< endl;
if (debug) Comm.Barrier();
if (verbose) cout << "\n\n*****Testing copy constructor" << endl<< endl;
Epetra_CrsMatrix B(AA);
EPETRA_TEST_ERR(check(B, NumMyEquations, NumGlobalEquations, NumMyEquations, NumGlobalEquations,
MyGlobalElements, verbose),ierr);
forierr = 0;
for (int i=0; i<NumMyEquations; i++) forierr += !(B.NumGlobalEntries(MyGlobalElements[i])==1);
EPETRA_TEST_ERR(forierr,ierr);
if (verbose) cout << "\n\nNumEntries function check OK" << endl<< endl;
if (debug) Comm.Barrier();
if (verbose) cout << "\n\n*****Testing local view constructor" << endl<< endl;
Epetra_CrsMatrix BV(View, AA.RowMap(), AA.ColMap(), 0);
forierr = 0;
int* Inds;
double* Vals;
for (int i = 0; i < NumMyEquations; i++) {
forierr += !(AA.ExtractMyRowView(i, NumEntries, Vals, Inds)==0);
forierr += !(BV.InsertMyValues(i, NumEntries, Vals, Inds)==0);
}
BV.FillComplete(false);
EPETRA_TEST_ERR(check(BV, NumMyEquations, NumGlobalEquations, NumMyEquations, NumGlobalEquations,
MyGlobalElements, verbose),ierr);
forierr = 0;
for (int i=0; i<NumMyEquations; i++) forierr += !(BV.NumGlobalEntries(MyGlobalElements[i])==1);
EPETRA_TEST_ERR(forierr,ierr);
if (verbose) cout << "\n\nNumEntries function check OK" << endl<< endl;
if (debug) Comm.Barrier();
if (verbose) cout << "\n\n*****Testing post construction modifications" << endl<< endl;
EPETRA_TEST_ERR(!(B.InsertGlobalValues(0, 1, &dble_one, &One)==-2),ierr);
// Release all objects
delete [] NumNz;
delete [] Values;
delete [] Indices;
delete [] MyGlobalElements;
if (verbose1) {
// Test ostream << operator (if verbose1)
// Construct a Map that puts 2 equations on each PE
int NumMyElements1 = 2;
int NumMyEquations1 = NumMyElements1;
int NumGlobalEquations1 = NumMyEquations1*NumProc;
Epetra_Map Map1(-1, NumMyElements1, 0, Comm);
// Get update list and number of local equations from newly created Map
int * MyGlobalElements1 = new int[Map1.NumMyElements()];
Map1.MyGlobalElements(MyGlobalElements1);
// Create an integer vector NumNz that is used to build the Petra Matrix.
// NumNz[i] is the Number of OFF-DIAGONAL term for the ith global equation on this processor
int * NumNz1 = new int[NumMyEquations1];
// We are building a tridiagonal matrix where each row has (-1 2 -1)
// So we need 2 off-diagonal terms (except for the first and last equation)
for (int i=0; i<NumMyEquations1; i++)
if (MyGlobalElements1[i]==0 || MyGlobalElements1[i] == NumGlobalEquations1-1)
NumNz1[i] = 1;
else
NumNz1[i] = 2;
// Create a Epetra_Matrix
Epetra_CrsMatrix A1(Copy, Map1, NumNz1);
// Add rows one-at-a-time
// Need some vectors to help
// Off diagonal Values will always be -1
double *Values1 = new double[2];
Values1[0] = -1.0; Values1[1] = -1.0;
int *Indices1 = new int[2];
double two1 = 2.0;
int NumEntries1;
forierr = 0;
for (int i=0; i<NumMyEquations1; i++)
{
if (MyGlobalElements1[i]==0)
{
Indices1[0] = 1;
NumEntries1 = 1;
}
else if (MyGlobalElements1[i] == NumGlobalEquations1-1)
{
Indices1[0] = NumGlobalEquations1-2;
NumEntries1 = 1;
}
else
{
Indices1[0] = MyGlobalElements1[i]-1;
Indices1[1] = MyGlobalElements1[i]+1;
NumEntries1 = 2;
}
forierr += !(A1.InsertGlobalValues(MyGlobalElements1[i], NumEntries1, Values1, Indices1)==0);
forierr += !(A1.InsertGlobalValues(MyGlobalElements1[i], 1, &two1, MyGlobalElements1+i)>0); // Put in the diagonal entry
}
EPETRA_TEST_ERR(forierr,ierr);
delete [] Indices1;
delete [] Values1;
// Finish up
EPETRA_TEST_ERR(!(A1.FillComplete(false)==0),ierr);
// Test diagonal extraction function
Epetra_Vector checkDiag(Map1);
EPETRA_TEST_ERR(!(A1.ExtractDiagonalCopy(checkDiag)==0),ierr);
forierr = 0;
for (int i=0; i<NumMyEquations1; i++) forierr += !(checkDiag[i]==two1);
EPETRA_TEST_ERR(forierr,ierr);
// Test diagonal replacement method
forierr = 0;
for (int i=0; i<NumMyEquations1; i++) checkDiag[i]=two1*two1;
EPETRA_TEST_ERR(forierr,ierr);
EPETRA_TEST_ERR(!(A1.ReplaceDiagonalValues(checkDiag)==0),ierr);
Epetra_Vector checkDiag1(Map1);
EPETRA_TEST_ERR(!(A1.ExtractDiagonalCopy(checkDiag1)==0),ierr);
forierr = 0;
for (int i=0; i<NumMyEquations1; i++) forierr += !(checkDiag[i]==checkDiag1[i]);
EPETRA_TEST_ERR(forierr,ierr);
if (verbose) cout << "\n\nDiagonal extraction and replacement OK.\n\n" << endl;
double orignorm = A1.NormOne();
EPETRA_TEST_ERR(!(A1.Scale(4.0)==0),ierr);
EPETRA_TEST_ERR(!(A1.NormOne()!=orignorm),ierr);
if (verbose) cout << "\n\nMatrix scale OK.\n\n" << endl;
if (verbose) cout << "\n\nPrint out tridiagonal matrix, each part on each processor.\n\n" << endl;
cout << A1 << endl;
// Release all objects
delete [] NumNz1;
delete [] MyGlobalElements1;
}
if (verbose) cout << "\n\n*****Testing LeftScale and RightScale" << endl << endl;
int NumMyElements2 = 7;
int NumMyRows2 = 1;//This value should not be changed without editing the
// code below.
Epetra_Map RowMap(-1,NumMyRows2,0,Comm);
Epetra_Map ColMap(NumMyElements2,NumMyElements2,0,Comm);
// The DomainMap needs to be different from the ColMap for the test to
// be meaningful.
Epetra_Map DomainMap(NumMyElements2,0,Comm);
int NumMyRangeElements2 = 0;
// We need to distribute the elements differently for the range map also.
if (MyPID % 2 == 0)
NumMyRangeElements2 = NumMyRows2*2; //put elements on even number procs
if (NumProc % 2 == 1 && MyPID == NumProc-1)
NumMyRangeElements2 = NumMyRows2; //If number of procs is odd, put
// the last NumMyElements2 elements on the last proc
Epetra_Map RangeMap(-1,NumMyRangeElements2,0,Comm);
Epetra_CrsMatrix A2(Copy,RowMap,ColMap,NumMyElements2);
double * Values2 = new double[NumMyElements2];
int * Indices2 = new int[NumMyElements2];
for (int i=0; i<NumMyElements2; i++) {
Values2[i] = i+MyPID;
Indices2[i]=i;
}
A2.InsertMyValues(0,NumMyElements2,Values2,Indices2);
A2.FillComplete(DomainMap,RangeMap,false);
Epetra_CrsMatrix A2copy(A2);
double * RowLeftScaleValues = new double[NumMyRows2];
double * ColRightScaleValues = new double[NumMyElements2];
int RowLoopLength = RowMap.MaxMyGID()-RowMap.MinMyGID()+1;
for (int i=0; i<RowLoopLength; i++)
RowLeftScaleValues[i] = (i + RowMap.MinMyGID() ) % 2 + 1;
// For the column map, all procs own all elements
for (int i=0; i<NumMyElements2;i++)
ColRightScaleValues[i] = i % 2 + 1;
int RangeLoopLength = RangeMap.MaxMyGID()-RangeMap.MinMyGID()+1;
double * RangeLeftScaleValues = new double[RangeLoopLength];
int DomainLoopLength = DomainMap.MaxMyGID()-DomainMap.MinMyGID()+1;
double * DomainRightScaleValues = new double[DomainLoopLength];
for (int i=0; i<RangeLoopLength; i++)
RangeLeftScaleValues[i] = 1.0/((i + RangeMap.MinMyGID() ) % 2 + 1);
for (int i=0; i<DomainLoopLength;i++)
DomainRightScaleValues[i] = 1.0/((i + DomainMap.MinMyGID() ) % 2 + 1);
Epetra_Vector xRow(View,RowMap,RowLeftScaleValues);
Epetra_Vector xCol(View,ColMap,ColRightScaleValues);
Epetra_Vector xRange(View,RangeMap,RangeLeftScaleValues);
Epetra_Vector xDomain(View,DomainMap,DomainRightScaleValues);
double A2infNorm = A2.NormInf();
double A2oneNorm = A2.NormOne();
if (verbose1) cout << A2;
EPETRA_TEST_ERR(A2.LeftScale(xRow),ierr);
double A2infNorm1 = A2.NormInf();
double A2oneNorm1 = A2.NormOne();
bool ScalingBroke = false;
if (A2infNorm1>2*A2infNorm||A2infNorm1<A2infNorm) {
EPETRA_TEST_ERR(-31,ierr);
ScalingBroke = true;
}
if (A2oneNorm1>2*A2oneNorm||A2oneNorm1<A2oneNorm) {
EPETRA_TEST_ERR(-32,ierr);
ScalingBroke = true;
}
if (verbose1) cout << A2;
EPETRA_TEST_ERR(A2.RightScale(xCol),ierr);
double A2infNorm2 = A2.NormInf();
double A2oneNorm2 = A2.NormOne();
if (A2infNorm2>=2*A2infNorm1||A2infNorm2<=A2infNorm1) {
EPETRA_TEST_ERR(-33,ierr);
ScalingBroke = true;
}
if (A2oneNorm2>2*A2oneNorm1||A2oneNorm2<=A2oneNorm1) {
EPETRA_TEST_ERR(-34,ierr);
ScalingBroke = true;
}
if (verbose1) cout << A2;
EPETRA_TEST_ERR(A2.RightScale(xDomain),ierr);
double A2infNorm3 = A2.NormInf();
double A2oneNorm3 = A2.NormOne();
// The last two scaling ops cancel each other out
if (A2infNorm3!=A2infNorm1) {
EPETRA_TEST_ERR(-35,ierr)
ScalingBroke = true;
}
if (A2oneNorm3!=A2oneNorm1) {
EPETRA_TEST_ERR(-36,ierr)
ScalingBroke = true;
}
if (verbose1) cout << A2;
EPETRA_TEST_ERR(A2.LeftScale(xRange),ierr);
double A2infNorm4 = A2.NormInf();
double A2oneNorm4 = A2.NormOne();
// The 4 scaling ops all cancel out
if (A2infNorm4!=A2infNorm) {
EPETRA_TEST_ERR(-37,ierr)
ScalingBroke = true;
}
if (A2oneNorm4!=A2oneNorm) {
EPETRA_TEST_ERR(-38,ierr)
ScalingBroke = true;
}
//
// Now try changing the values underneath and make sure that
// telling one process about the change causes NormInf() and
// NormOne() to recompute the norm on all processes.
//
double *values;
int num_my_rows = A2.NumMyRows() ;
int num_entries;
for ( int i=0 ; i< num_my_rows; i++ ) {
EPETRA_TEST_ERR( A2.ExtractMyRowView( i, num_entries, values ), ierr );
for ( int j = 0 ; j <num_entries; j++ ) {
values[j] *= 2.0;
}
}
if ( MyPID == 0 )
A2.SumIntoGlobalValues( 0, 0, 0, 0 ) ;
double A2infNorm5 = A2.NormInf();
double A2oneNorm5 = A2.NormOne();
if (A2infNorm5!=2.0 * A2infNorm4) {
EPETRA_TEST_ERR(-39,ierr)
ScalingBroke = true;
}
if (A2oneNorm5!= 2.0 * A2oneNorm4) {
EPETRA_TEST_ERR(-40,ierr)
ScalingBroke = true;
}
//
// Restore the values underneath
//
for ( int i=0 ; i< num_my_rows; i++ ) {
EPETRA_TEST_ERR( A2.ExtractMyRowView( i, num_entries, values ), ierr );
for ( int j = 0 ; j <num_entries; j++ ) {
values[j] /= 2.0;
}
}
if (verbose1) cout << A2;
if (ScalingBroke) {
if (verbose) cout << endl << "LeftScale and RightScale tests FAILED" << endl << endl;
}
else {
if (verbose) cout << endl << "LeftScale and RightScale tests PASSED" << endl << endl;
}
Comm.Barrier();
if (verbose) cout << "\n\n*****Testing InvRowMaxs and InvColMaxs" << endl << endl;
if (verbose1) cout << A2 << endl;
EPETRA_TEST_ERR(A2.InvRowMaxs(xRow),ierr);
EPETRA_TEST_ERR(A2.InvRowMaxs(xRange),ierr);
if (verbose1) cout << xRow << endl << xRange << endl;
if (verbose) cout << "\n\n*****Testing InvRowSums and InvColSums" << endl << endl;
bool InvSumsBroke = false;
// Works!
EPETRA_TEST_ERR(A2.InvRowSums(xRow),ierr);
if (verbose1) cout << xRow;
EPETRA_TEST_ERR(A2.LeftScale(xRow),ierr);
float A2infNormFloat = A2.NormInf();
if (verbose1) cout << A2 << endl;
if (fabs(1.0-A2infNormFloat) > 1.e-5) {
EPETRA_TEST_ERR(-41,ierr);
InvSumsBroke = true;
}
// Works
int expectedcode = 1;
if (Comm.NumProc()>1) expectedcode = 0;
EPETRA_TEST_ERR(!(A2.InvColSums(xDomain)==expectedcode),ierr); // This matrix has a single row, the first column has a zero, so a warning is issued.
if (verbose1) cout << xDomain << endl;
EPETRA_TEST_ERR(A2.RightScale(xDomain),ierr);
float A2oneNormFloat2 = A2.NormOne();
if (verbose1) cout << A2;
if (fabs(1.0-A2oneNormFloat2)>1.e-5) {
EPETRA_TEST_ERR(-42,ierr)
InvSumsBroke = true;
}
// Works!
EPETRA_TEST_ERR(A2.InvRowSums(xRange),ierr);
if (verbose1) cout << xRange;
EPETRA_TEST_ERR(A2.LeftScale(xRange),ierr);
float A2infNormFloat2 = A2.NormInf(); // We use a float so that rounding error
// will not prevent the sum from being 1.0.
if (verbose1) cout << A2;
if (fabs(1.0-A2infNormFloat2)>1.e-5) {
cout << "InfNorm should be = 1, but InfNorm = " << A2infNormFloat2 << endl;
EPETRA_TEST_ERR(-43,ierr);
InvSumsBroke = true;
}
// Doesn't work - may not need this test because column ownership is not unique
/* EPETRA_TEST_ERR(A2.InvColSums(xCol),ierr);
cout << xCol;
EPETRA_TEST_ERR(A2.RightScale(xCol),ierr);
float A2oneNormFloat = A2.NormOne();
cout << A2;
if (fabs(1.0-A2oneNormFloat)>1.e-5) {
EPETRA_TEST_ERR(-44,ierr);
InvSumsBroke = true;
}
*/
delete [] ColRightScaleValues;
delete [] DomainRightScaleValues;
if (verbose) cout << "Begin partial sum testing." << endl;
// Test with a matrix that has partial sums for a subset of the rows
// on multiple processors. (Except for the serial case, of course.)
int NumMyRows3 = 2; // Changing this requires further changes below
int * myGlobalElements = new int[NumMyRows3];
for (int i=0; i<NumMyRows3; i++) myGlobalElements[i] = MyPID+i;
Epetra_Map RowMap3(NumProc*2, NumMyRows3, myGlobalElements, 0, Comm);
int NumMyElements3 = 5;
Epetra_CrsMatrix A3(Copy, RowMap3, NumMyElements3);
double * Values3 = new double[NumMyElements3];
int * Indices3 = new int[NumMyElements3];
for (int i=0; i < NumMyElements3; i++) {
Values3[i] = (int) (MyPID + (i+1));
Indices3[i]=i;
}
for (int i=0; i<NumMyRows3; i++) {
A3.InsertGlobalValues(myGlobalElements[i],NumMyElements3,Values3,Indices3);
}
Epetra_Map RangeMap3(NumProc+1, 0, Comm);
Epetra_Map DomainMap3(NumMyElements3, 0, Comm);
EPETRA_TEST_ERR(A3.FillComplete(DomainMap3, RangeMap3,false),ierr);
if (verbose1) cout << A3;
Epetra_Vector xRange3(RangeMap3,false);
Epetra_Vector xDomain3(DomainMap3,false);
EPETRA_TEST_ERR(A3.InvRowSums(xRange3),ierr);
if (verbose1) cout << xRange3;
EPETRA_TEST_ERR(A3.LeftScale(xRange3),ierr);
float A3infNormFloat = A3.NormInf();
if (verbose1) cout << A3;
if (1.0!=A3infNormFloat) {
cout << "InfNorm should be = 1, but InfNorm = " << A3infNormFloat <<endl;
EPETRA_TEST_ERR(-61,ierr);
InvSumsBroke = true;
}
// we want to take the transpose of our matrix and fill in different values.
int NumMyColumns3 = NumMyRows3;
Epetra_Map ColMap3cm(RowMap3);
Epetra_Map RowMap3cm(A3.ColMap());
Epetra_CrsMatrix A3cm(Copy,RowMap3cm,ColMap3cm,NumProc+1);
double *Values3cm = new double[NumMyColumns3];
int * Indices3cm = new int[NumMyColumns3];
for (int i=0; i<NumMyColumns3; i++) {
Values3cm[i] = MyPID + i + 1;
Indices3cm[i]= i + MyPID;
}
for (int ii=0; ii<NumMyElements3; ii++) {
A3cm.InsertGlobalValues(ii, NumMyColumns3, Values3cm, Indices3cm);
}
// The DomainMap and the RangeMap from the last test will work fine for
// the RangeMap and DomainMap, respectively, but I will make copies to
// avaoid confusion when passing what looks like a DomainMap where we
// need a RangeMap and vice vera.
Epetra_Map RangeMap3cm(DomainMap3);
Epetra_Map DomainMap3cm(RangeMap3);
EPETRA_TEST_ERR(A3cm.FillComplete(DomainMap3cm,RangeMap3cm),ierr);
if (verbose1) cout << A3cm << endl;
// Again, we can copy objects from the last example.
//Epetra_Vector xRange3cm(xDomain3); //Don't use at this time
Epetra_Vector xDomain3cm(DomainMap3cm,false);
EPETRA_TEST_ERR(A3cm.InvColSums(xDomain3cm),ierr);
if (verbose1) cout << xDomain3cm << endl;
EPETRA_TEST_ERR(A3cm.RightScale(xDomain3cm),ierr);
float A3cmOneNormFloat = A3cm.NormOne();
if (verbose1) cout << A3cm << endl;
if (1.0!=A3cmOneNormFloat) {
cout << "OneNorm should be = 1, but OneNorm = " << A3cmOneNormFloat << endl;
EPETRA_TEST_ERR(-62,ierr);
InvSumsBroke = true;
}
if (verbose) cout << "End partial sum testing" << endl;
if (verbose) cout << "Begin replicated testing" << endl;
// We will now view the shared row as a repliated row, rather than one
// that has partial sums of its entries on mulitple processors.
// We will reuse much of the data used for the partial sum tesitng.
Epetra_Vector xRow3(RowMap3,false);
Epetra_CrsMatrix A4(Copy, RowMap3, NumMyElements3);
for (int ii=0; ii < NumMyElements3; ii++) {
Values3[ii] = (int)((ii*.6)+1.0);
}
for (int ii=0; ii<NumMyRows3; ii++) {
A4.InsertGlobalValues(myGlobalElements[ii],NumMyElements3,Values3,Indices3);
}
EPETRA_TEST_ERR(A4.FillComplete(DomainMap3, RangeMap3,false),ierr);
if (verbose1) cout << A4 << endl;
// The next two lines should be expanded into a verifiable test.
EPETRA_TEST_ERR(A4.InvRowMaxs(xRow3),ierr);
EPETRA_TEST_ERR(A4.InvRowMaxs(xRange3),ierr);
if (verbose1) cout << xRow3 << xRange3;
EPETRA_TEST_ERR(A4.InvRowSums(xRow3),ierr);
if (verbose1) cout << xRow3;
EPETRA_TEST_ERR(A4.LeftScale(xRow3),ierr);
float A4infNormFloat = A4.NormInf();
if (verbose1) cout << A4;
if (2.0!=A4infNormFloat && NumProc != 1) {
if (verbose1) cout << "InfNorm should be = 2 (because one column is replicated on two processors and NormOne() does not handle replication), but InfNorm = " << A4infNormFloat <<endl;
EPETRA_TEST_ERR(-63,ierr);
InvSumsBroke = true;
}
else if (1.0!=A4infNormFloat && NumProc == 1) {
if (verbose1) cout << "InfNorm should be = 1, but InfNorm = " << A4infNormFloat <<endl;
EPETRA_TEST_ERR(-63,ierr);
InvSumsBroke = true;
}
Epetra_Vector xCol3cm(ColMap3cm,false);
Epetra_CrsMatrix A4cm(Copy, RowMap3cm, ColMap3cm, NumProc+1);
//Use values from A3cm
for (int ii=0; ii<NumMyElements3; ii++) {
A4cm.InsertGlobalValues(ii,NumMyColumns3,Values3cm,Indices3cm);
}
EPETRA_TEST_ERR(A4cm.FillComplete(DomainMap3cm, RangeMap3cm,false),ierr);
if (verbose1) cout << A4cm << endl;
// The next two lines should be expanded into a verifiable test.
EPETRA_TEST_ERR(A4cm.InvColMaxs(xCol3cm),ierr);
EPETRA_TEST_ERR(A4cm.InvColMaxs(xDomain3cm),ierr);
if (verbose1) cout << xCol3cm << xDomain3cm;
EPETRA_TEST_ERR(A4cm.InvColSums(xCol3cm),ierr);
if (verbose1) cout << xCol3cm << endl;
EPETRA_TEST_ERR(A4cm.RightScale(xCol3cm),ierr);
float A4cmOneNormFloat = A4cm.NormOne();
if (verbose1) cout << A4cm << endl;
if (2.0!=A4cmOneNormFloat && NumProc != 1) {
if (verbose1) cout << "OneNorm should be = 2 (because one column is replicated on two processors and NormOne() does not handle replication), but OneNorm = " << A4cmOneNormFloat << endl;
EPETRA_TEST_ERR(-64,ierr);
InvSumsBroke = true;
}
else if (1.0!=A4cmOneNormFloat && NumProc == 1) {
if (verbose1) cout << "OneNorm should be = 1, but OneNorm = " << A4infNormFloat <<endl;
EPETRA_TEST_ERR(-64,ierr);
InvSumsBroke = true;
}
if (verbose) cout << "End replicated testing" << endl;
if (InvSumsBroke) {
if (verbose) cout << endl << "InvRowSums tests FAILED" << endl << endl;
}
else
if (verbose) cout << endl << "InvRowSums tests PASSED" << endl << endl;
A3cm.PutScalar(2.0);
int nnz_A3cm = A3cm.Graph().NumGlobalNonzeros();
double check_frobnorm = sqrt(nnz_A3cm*4.0);
double frobnorm = A3cm.NormFrobenius();
bool frobnorm_test_failed = false;
if (fabs(check_frobnorm-frobnorm) > 5.e-5) {
frobnorm_test_failed = true;
}
if (frobnorm_test_failed) {
if (verbose) std::cout << "Frobenius-norm test FAILED."<<std::endl;
EPETRA_TEST_ERR(-65, ierr);
}
delete [] Values2;
delete [] Indices2;
delete [] myGlobalElements;
delete [] Values3;
delete [] Indices3;
delete [] Values3cm;
delete [] Indices3cm;
delete [] RangeLeftScaleValues;
delete [] RowLeftScaleValues;
#ifdef EPETRA_MPI
MPI_Finalize() ;
#endif
/* end main
*/
return ierr ;
}
void ConstructA_CG2(const mesh& Mesh, FullMatrix& A)
{
const int NumPhysElems = Mesh.get_NumPhysElems();
const int NumBndNodes = Mesh.get_SubNumBndNodes();
const int Asize = Mesh.get_SubNumPhysNodes();
assert_eq(Asize,A.get_NumRows());
assert_eq(Asize,A.get_NumCols());
dTensor1 A1(6);
dTensor1 A2(6);
dTensor1 A3(6);
dTensor1 A4(6);
dTensor1 A5(6);
dTensor1 A6(6);
A1.set(1, -oneninth );
A1.set(2, 4.0*oneninth );
A1.set(3, -oneninth );
A1.set(4, 4.0*oneninth );
A1.set(5, 4.0*oneninth );
A1.set(6, -oneninth );
A2.set(1, -onethird );
A2.set(2, 0.0 );
A2.set(3, onethird );
A2.set(4, -4.0*onethird );
A2.set(5, 4.0*onethird );
A2.set(6, 0.0 );
A3.set(1, -onethird );
A3.set(2, -4.0*onethird );
A3.set(3, 0.0 );
A3.set(4, 0.0 );
A3.set(5, 4.0*onethird );
A3.set(6, onethird );
A4.set(1, 4.0 );
A4.set(2, -4.0 );
A4.set(3, 0.0 );
A4.set(4, -4.0 );
A4.set(5, 4.0 );
A4.set(6, 0.0 );
A5.set(1, 2.0 );
A5.set(2, -4.0 );
A5.set(3, 2.0 );
A5.set(4, 0.0 );
A5.set(5, 0.0 );
A5.set(6, 0.0 );
A6.set(1, 2.0 );
A6.set(2, 0.0 );
A6.set(3, 0.0 );
A6.set(4, -4.0 );
A6.set(5, 0.0 );
A6.set(6, 2.0 );
dTensor2 spts(3,2);
spts.set(1,1, 1.0/3.0 );
spts.set(1,2, -1.0/6.0 );
spts.set(2,1, -1.0/6.0 );
spts.set(2,2, -1.0/6.0 );
spts.set(3,1, -1.0/6.0 );
spts.set(3,2, 1.0/3.0 );
dTensor1 wgts(3);
wgts.set(1, 1.0/6.0 );
wgts.set(2, 1.0/6.0 );
wgts.set(3, 1.0/6.0 );
// Loop over all elements in the mesh
for (int i=1; i<=NumPhysElems; i++)
{
// Information for element i
iTensor1 tt(6);
for (int k=1; k<=6; k++)
{ tt.set(k, Mesh.get_node_subs(i,k) ); }
// Evaluate gradients of the Lagrange polynomials on Gauss quadrature points
dTensor2 gpx(6,3);
dTensor2 gpy(6,3);
for (int m=1; m<=3; m++)
{
double xi = spts.get(m,1);
double eta = spts.get(m,2);
for (int k=1; k<=6; k++)
{
double gp_xi = A2.get(k) + 2.0*A5.get(k)*xi + A4.get(k)*eta;
double gp_eta = A3.get(k) + A4.get(k)*xi + 2.0*A6.get(k)*eta;
gpx.set(k,m, Mesh.get_jmat(i,1,1)*gp_xi
+ Mesh.get_jmat(i,1,2)*gp_eta );
gpy.set(k,m, Mesh.get_jmat(i,2,1)*gp_xi
+ Mesh.get_jmat(i,2,2)*gp_eta );
}
}
// Entries of the stiffness matrix A
double Area = Mesh.get_area_prim(i);
for (int j=1; j<=6; j++)
for (int k=1; k<=6; k++)
{
double tmp = A.get(tt.get(j),tt.get(k));
for (int m=1; m<=3; m++)
{
tmp = tmp + 2.0*Area*wgts.get(m)*(gpx.get(j,m)*gpx.get(k,m)+gpy.get(j,m)*gpy.get(k,m));
}
A.set(tt.get(j),tt.get(k), tmp );
}
}
// Replace boundary node equations by Dirichlet boundary condition enforcement
for (int i=1; i<=NumBndNodes; i++)
{
const int j=Mesh.get_sub_bnd_node(i);
for (int k=1; k<=A.get_NumCols(); k++)
{
A.set(j,k, 0.0 );
}
for (int k=1; k<=A.get_NumRows(); k++)
{
A.set(k,j, 0.0 );
}
A.set(j,j, 1.0 );
}
// Get sparse structure representation
A.Sparsify();
}
int main(void){
Marray<double,4> A4(3,3,3,3);
Marray<double,4> B4(3,3,3,3);
Marray<double,4> C4Test(3,3,3,3);
Marray<double,4> C4(3,3,3,3);
A4.sucesion(0,1);
B4.sucesion(0,1);
Index<'i'> iG;
Index<'j'> jG;
Index<'k'> kG;
Index<'l'> lG;
Index<'m'> mG;
Index<'n'> nG;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(k,l,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(kG,lG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(k,m,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(kG,mG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(k,m,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(kG,mG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(l,k,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(lG,kG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(l,m,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(lG,mG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(l,m,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(lG,mG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(m,k,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(mG,kG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(m,k,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(mG,kG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(m,l,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(mG,lG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(m,l,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(mG,lG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(m,n,k,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(mG,nG,kG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,k,l)*B4(m,n,l,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,kG,lG)*B4(mG,nG,lG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,j,l,k)*B4(l,k,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,jG,lG,kG)*B4(lG,kG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(k,l,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(kG,lG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(k,m,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(kG,mG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(k,m,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(kG,mG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(l,k,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(lG,kG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(l,m,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(lG,mG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(l,m,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(lG,mG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(m,k,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(mG,kG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(m,k,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(mG,kG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(m,l,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(mG,lG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(m,l,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(mG,lG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(m,n,k,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(mG,nG,kG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,j,l)*B4(m,n,l,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,jG,lG)*B4(mG,nG,lG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(k,l,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(kG,lG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(k,m,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(kG,mG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(k,m,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(kG,mG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(l,k,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(lG,kG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(l,m,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(lG,mG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(l,m,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(lG,mG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(m,k,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(mG,kG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(m,k,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(mG,kG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(m,l,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(mG,lG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(m,l,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(mG,lG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(m,n,k,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(mG,nG,kG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(i,k,l,j)*B4(m,n,l,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(iG,kG,lG,jG)*B4(mG,nG,lG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(k,l,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(kG,lG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(k,m,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(kG,mG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(k,m,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(kG,mG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(l,k,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(lG,kG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(l,m,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(lG,mG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(l,m,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(lG,mG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(m,k,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(mG,kG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(m,k,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(mG,kG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(m,l,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(mG,lG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(m,l,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(mG,lG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(m,n,k,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(mG,nG,kG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,j,l)*B4(m,n,l,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,jG,lG)*B4(mG,nG,lG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(k,l,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(kG,lG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(k,m,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(kG,mG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(k,m,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(kG,mG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(l,k,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(lG,kG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(l,m,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(lG,mG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(l,m,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(lG,mG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(m,k,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(mG,kG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(m,k,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(mG,kG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(m,l,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(mG,lG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(m,l,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(mG,lG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(m,n,k,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(mG,nG,kG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,i,l,j)*B4(m,n,l,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,iG,lG,jG)*B4(mG,nG,lG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(k,l,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(kG,lG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(k,m,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(kG,mG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(k,m,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(kG,mG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(l,k,m,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(lG,kG,mG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(l,m,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(lG,mG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(l,m,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(lG,mG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(m,k,l,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(mG,kG,lG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(m,k,n,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(mG,kG,nG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(m,l,k,n);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(mG,lG,kG,nG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(m,l,n,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(mG,lG,nG,kG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(m,n,k,l);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(mG,nG,kG,lG);
assert(C4==C4Test);
C4=0;
for (int i=0;i<3;i++) {
for (int j=0;j<3;j++){
for (int l=0;l<3;l++){
for (int m=0;m<3;m++){
for (int n=0;n<3;n++){
for(int k=0;k<3;k++){
C4(i,j,m,n)+=A4(k,l,i,j)*B4(m,n,l,k);
}
}
}
}
}
}
C4Test(iG,jG,mG,nG)=A4(kG,lG,iG,jG)*B4(mG,nG,lG,kG);
assert(C4==C4Test);
C4=0;
}
int main(void)
{
Bureaucrat bob("bob", 45);
Bureaucrat jim("jim", 150);
Bureaucrat zac("zac", 2);
Form A4("A4", 45, 45);
Form A5("A5", 150, 21);
ShrubberyCreationForm Creation("home");
PresidentialPardonForm Pardon("Amedy Coulibaly");
RobotomyRequestForm Robot("Zaz");
try
{
Form a("fifi", 0, 2);
}
catch (std::exception const& e)
{
std::cout << "Form a: " << e.what() << std::endl;
}
try
{
Form b("fifi", 42, 151);
}
catch (std::exception const& e)
{
std::cout << "Form b: " << e.what() << std::endl;
}
std::cout << A4 << std::endl << A5 << std::endl << std::endl;
std::cout << bob << std::endl << jim << std::endl << std::endl;
try
{
A4.beSigned(jim);
}
catch (std::exception const& e)
{
std::cout << "Form A4: " << e.what() << std::endl;
}
std::cout << A4 << std::endl << std::endl;
try
{
A4.beSigned(bob);
}
catch (std::exception const& e)
{
std::cout << "Form A4: " << e.what() << std::endl;
}
std::cout << A4 << std::endl << std::endl;
bob.signForm(A4);
bob.signForm(A5);
jim.signForm(A4);
jim.executeForm(Creation);
bob.executeForm(Creation);
zac.signForm(Pardon);
zac.executeForm(Pardon);
jim.executeForm(Pardon);
zac.signForm(Robot);
zac.executeForm(Robot);
zac.executeForm(Robot);
zac.executeForm(Robot);
zac.executeForm(Robot);
jim.executeForm(Robot);
}
