| | | |

Minicurso de C++ para Matemática

4 Elementos da computação matricial

Ajude a manter o site livre, gratuito e sem propagandas. Colabore!

4.5 Inicialização

A biblioteca Eigen conta com métodos para inicialização de matrizes e arranjos.

  • •

    Zero()

    ⬇
    1arr = Eigen::ArrayXd::Zero(3)
    arr =
    0
    0
    0
    ⬇
    1v = Eigen::RowVectorXd::Zero(2)
    v = 0 0
    ⬇
    1a = Eigen::MatrixXd::Zero(2,3)
    a =
    0 0 0
    0 0 0
  • •

    Ones()

    ⬇
    1arr = Eigen::ArrayXd::Ones(2)
    arr =
    1
    1
  • •

    Constant()

    ⬇
    1a = Eigen::MatrixXd::Constant(2,3,0.5)
    a =
    0.5 0.5 0.5
    0.5 0.5 0.5
  • •

    Random()

    ⬇
    1a = Eigen::MatrixXd::Random(3,2)
    a =
    0.680375 0.59688
    -0.211234 0.823295
    0.566198 -0.604897
  • •

    Identity()

    ⬇
    1a = Eigen::MatrixXd::Identity(3,3)
    a =
    1 0 0
    0 1 0
    0 0 1
  • •

    LinSpaced()

    ⬇
    1arr = Eigen::RowVectorXd::LinSpaced(5, 0, 1)
    arr =
    0 0.25 0.5 0.75 1
E. 4.5.1.

Considere as seguintes partições uniformes de intervalos

x[0,1]={0=x0<x1<⋯<xnx+1=1}, (4.13)
y[1,2]={1=y0<y1<⋯<yny+1=2}, (4.14)

onde nx=5 e ny=3. Implemente uma função X, Y = meshgrid(x, y), em que X e Y são os arranjos nx×ny que contém as coordenadas dos pontos do produto cartesiano x[0,1]×y[1,2]. Isto é, a grade de pontos (Xi,j,Yi,j)=(xi,yj), i=0,1,…,nx e j=0,1,…,ny.


⬇
1#include <iostream>
2#include <eigen3/Eigen/Eigen>
3
4void meshgrid(const Eigen::ArrayXd& x, const Eigen::ArrayXd& y,
5 Eigen::ArrayXXd& X, Eigen::ArrayXXd& Y)
6{
7 X = x.replicate(1, y.size());
8 Y = y.transpose().replicate(x.size(), 1);
9}
10
11int main()
12{
13 Eigen::ArrayXd x = Eigen::ArrayXd::LinSpaced(5, 0, 1);
14 Eigen::ArrayXd y = Eigen::ArrayXd::LinSpaced(3, 1, 2);
15
16 Eigen::ArrayXXd X;
17 Eigen::ArrayXXd Y;
18 meshgrid(x, y, X, Y);
19
20 std::cout << "X:\n" << X << "\n";
21 std::cout << "Y:\n" << Y << "\n";
22
23 return 0;
24}
E. 4.5.2.

Implemente uma função para computar a inverse de uma matriz não-singular pelo método de eliminação gaussiana. Verifique seu código com o método A.inverse() da Eigen.


⬇
1Eigen::MatrixXd inverse(const Eigen::MatrixXd& A)
2{
3 // extendida
4 Eigen::MatrixXd E(A.rows(), 2 * A.cols());
5 E << A, Eigen::MatrixXd::Identity(A.rows(), A.cols());
6
7 // escalona
8 for (int j = 0; j < A.cols()-1; ++j) {
9 for (int i = j+1; i < A.rows(); ++i) {
10 E.row(i) -= E(i,j)/E(j,j) * E.row(j);
11 }
12 }
13 // reduzida
14 for (int j = A.cols()-1; j > 0; --j) {
15 for (int i = j-1; i >= 0; --i) {
16 E.row(i) -= E(i,j)/E(j,j) * E.row(j);
17 }
18 }
19 // normaliza
20 for (int j = 0; j < A.cols(); ++j) {
21 E.row(j) /= E(j,j);
22 }
23
24 return E.rightCols(A.cols());
25}

Envie seu comentário

Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

Opcional. Preencha seu nome para que eu possa lhe contatar.
Opcional. Preencha seu e-mail para que eu possa lhe contatar.
As informações preenchidas são enviadas por e-mail para o desenvolvedor do site e tratadas de forma privada. Consulte a política de uso de dados para mais informações.

Licença Creative Commons
Este texto é disponibilizado nos termos da Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional. Ícones e elementos gráficos podem estar sujeitos a condições adicionais.

Pedro H A Konzen
| | | |