tops.cpp

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys is free software; you can redistribute it and/or modify it under the      *
 * terms of the GNU General Public License as published by the Free Software         *
 * Foundation; either version 2 of the License, or (at your option) any later        *
 * version.                                                                          *
 *                                                                                   *
 * MechSys is distributed in the hope that it will be useful, but WITHOUT ANY        *
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A   *
 * PARTICULAR PURPOSE. See the GNU General Public License for more details.          *
 *                                                                                   *
 * You should have received a copy of the GNU General Public License along with      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#include <iostream>
#include <cmath>

#include "tensors/tensors.h"
#include "tensors/operators.h"

using namespace std;
using namespace Tensors;
using blitz::dot;

int main(int argc, char **argv)
{
    cout << "new_mechsys\n\n";

    Tensor2 x; x(0)=.4; x(1)=.5; x(2)=.6; x(3)=1*sqrt(2.0); x(4)=2*sqrt(2.0); x(5)=3*sqrt(2.0);
    Tensor2 y; y(0)= 3; y(1)= 2; y(2)= 1; y(3)=3*sqrt(2.0); y(4)=2*sqrt(2.0); y(5)=1*sqrt(2.0);
    Tensor2 z;
    Tensor2 w;
    Tensor4 A;
    Tensor4 B;
    Tensor4 C;
    Tensor4 D;
    Tensor4 W;

    cout << "x =\n" << x << endl;
    cout << "y =\n" << y << endl;

    // 1) ----------------------------------  sc = a * b
    cout << "x * y =\n" << dot(x,y) << endl;
    // 5) ------------------------------  A = x dyadic y
    Dyad(x,y,A);
    cout << "A = x dyadic y =\n" << A << endl;
    // 2) -----------------------------------  y = x * A
    Dot(x,A,y);
    cout << "y = x * A =\n" << y << endl;
    // 3) -----------------------------------  y = A * x
    Dot(A,x,y);
    cout << "y = A * x =\n" << y << endl;
    // 5) ------------------------------  B = x dyadic y
    Dyad(x,y,B);
    cout << "B = x dyadic y =\n" << B << endl;
    // 4) -----------------------------------  C = A * B
    Dot(A,B,C);
    cout << "C = A * B =\n" << C << endl;
    //    ---------------------------------  y = a*x + y
    y = 0.1*x + y; //Axpy(0.1,x,y);
    cout << "y = 0.1*x + y =\n" << y << endl;
    // 7) ------------------------  A = a*(x dyad y) + A
    Ger(0.01,x,y,A);
    cout << "A = 0.5*(x dyad y) + A =\n" << A << endl;
    // 8) ------------------  C = a*(A*x) dyad (y*B) + C
    GerX(1e-7,A,x,y,B,C,D);
    cout << "D = 1e-6*(A*x) dyad (y*B) + C =\n" << D << endl;

    //   ---------------------------------  y = a*x
    y = 0.1*x; //CopyScale(0.1,x,y);
    cout << "y = 0.1*x =\n" << y << endl;
    //   ---------------------------------  z = x + y
    z = x + y; //Add(x,y, z);
    cout << "z = x + y =\n" << z << endl;
    //   ---------------------------------  w = x + y + z
    w = x + y + z; //Add(x,y,z, w);
    cout << "w = x + y + z =\n" << w << endl;
    //   ---------------------------------  w = a*x + b*y + c*z
    w = x + 2.0*y + 3.0*z; //AddScaled(1.0,x, 2.0,y, 3.0,z, w);
    cout << "w = 1*x + 2*y + 3*z =\n" << w << endl;
    // 6) ---------------------------------  Z = a*X + b*Y
    AddScaled(1.0,A, 2.0,B, W);
    cout << "W = 1*A + 2*B =\n" << W << endl;

    // 9) ---------------------------------  B = a * B
    Scale(2.0,B);
    cout << " B = 2.0*B =\n" << B << endl;
    // 10) --------------------------------  B = a * A
    CopyScale(2.0,A,B);
    cout << " B = 2.0*A =\n" << B << endl;
    // 11) --------------------------------  s = xt * A * y
    cout << " xt * A * y = " << Reduce(x,A,y) << endl;

    return 0;
}

---