My Project
Public Member Functions | Public Attributes | List of all members
LineMesh Class Reference

Contains mesh data and has function to calculate and retrieve mesh properties. More...

#include <LineMesh.h>

Public Member Functions

 LineMesh (std::string fileName)
 Constructor for the LineMeshClass.
 
void transformCoordinates ()
 Transforms coordinates for computation purposes. More...
 
void calculatePrincipalMomentOfAreas ()
 Calculates the principal moment of areas EIxp and EIyp.
 
void calculateAreaStiffness ()
 Calculates the area stiffness.
 
void printCoordinates ()
 Prints node coordinates.
 
void calculateMeshProperties ()
 Calculates mesh properties. More...
 
void calculateBendingStiffness ()
 Calculates seccond area moments. More...
 
void calculateAnglePrincipalAxes ()
 Calculates angle of the principal axes. More...
 
void printCellAreas ()
 Prints cell areas.
 
void printCells ()
 Prints each cell, and it's elements.
 
void constructBMatrix ()
 Constructs coefficiant matrix \( \textbf{B} \). More...
 
void constructAVector (CycleDetection c)
 Constructs area vector a. More...
 
void solveSystemEquation ()
 Solves the system of equations. More...
 
void calculateStVenantStiffness (CycleDetection c)
 Calculates the St.Venant stiffness \( GI_t \). More...
 
void calculateShearFlow ()
 Calculates the shear flow for all elements in the cross-section.
 
void calculateOmega_c ()
 Calculates \( \omega_c \) for all the elements. More...
 
std::vector< LineElement * > findCommonElements (std::vector< LineElement * > a, std::vector< LineElement * > b)
 Finds common elements in two vectors, could be moved to a UTILS class. More...
 
std::vector< LineElement * > DFS ()
 Creates a vector of LineElement pointers that are sorted in a DFS fashion, could be extracted to a UTILS class. More...
 
bool contains (std::vector< int > a, int b)
 Checks wether a vector of ints contains a certain int, could be placed in a UTILS class. More...
 
void printOmega ()
 Prints omega values.
 
void printOmega_c ()
 prints omega_c values
 
void printDeltaOmega_c ()
 Prints delta_Omega_c values.
 
void calculateShearCenter ()
 Calculates shear center of the cross-section by summing the shear centers of each individual element.
 
void calculateOmega ()
 Calculates omega for each node in the cross-section.
 
void calculateWarpingStiffness ()
 Calculates the warping stiffness (EI_w) for the mesh by summing the warping stiffness found in each element.
 
void calculateOmegaIntersection ()
 Iterates through all elements and finds an omega intersection point if it exists.
 
void calculateSigmaXIntersection (int type, std::vector< std::vector< std::vector< double >>> *intersectionPoints, std::vector< std::vector< bool >> *intersection)
 Iterates through all elements and finds /f$ /f$ intersection values if they exist. More...
 
void calculateOmegaIntersection (int type, std::vector< std::vector< std::vector< double >>> *intersectionPoints, std::vector< std::vector< bool >> *intersection)
 Iterates through all elements and finds sigma_x intersection values for omega diagrams if they exist. More...
 
void calculateEk ()
 Calculates average E value of all elements surrounding a node.
 
void calculateAxialStress ()
 Calculates the resulting axial stress \( \sigma_x \) for all nodes in the cross-section, as well as axial stress due to N, Mx, My and B. More...
 
void calculatePureStvTorsionStress ()
 Calculates the pure St.Venants torsion stress. More...
 
void addElementPoints (VectorXd f_d, int type)
 Adds points along the element used for visualization of quadratic functions. More...
 
void findElementIntersections (VectorXd f_d, int type)
 Finds the element intersection points for quadratic functions along the element. More...
 
void calculateNodalTau (VectorXd f_d, int type)
 Calculates tau values for the nodes. More...
 
void initiateCVectors ()
 Initializes the C vectors for each element. More...
 
void createA1Matrix ()
 Creates A1 matrix. More...
 
void createA2Matrix ()
 Creates A2 matrix. More...
 
void calculateG1Matrix ()
 Calculates G1 matrix. More...
 
void calculateG2Matrix ()
 Calculates G2 matrix. More...
 
void calculateQ0 (VectorXd f_d, int type)
 Calculates q0. More...
 
void printEigenMatrix (MatrixXd A, std::string s)
 prints out a matrix on Eigen format More...
 
void initializeMatrices ()
 Initializes matrices. More...
 
double calculateQs (double s, LineElement *element, VectorXd f_d, int type)
 Calculates the shear value at a distance s along the element. More...
 
void calculateTau (VectorXd f_d, int type)
 Calculates tau for different applied loads. More...
 
void calculateTauSTV ()
 Calculates tau for applied T_stv.
 
void findMidPoints ()
 Finds the middle points of each element.
 
void findElementsNextToNode ()
 Finds the number of elements that are neighboring each node.
 
void findIntersections ()
 Finds diagram intersections for Sigma_x as well as omega.
 
void calculateKappaX ()
 Calculates shear deformation factor x. More...
 
void calculateKappaY ()
 Calculates shear deformation factor y. More...
 
void calculateResultingSigmaExtra ()
 Calculates to resulting sigma for all extra points in the element.
 
double calculateVonMisesStress (LineElement *element, int j)
 Calculates von mises stress. More...
 
void calculateEffectiveStress ()
 Calculates effective stress for cross-section.
 

Public Attributes

int TAU_DUE_TO_VX = 0
 Int corrosponding to tau due to Vx.
 
int TAU_DUE_TO_VY = 1
 Int corrosponding to tau due to Vy.
 
int TAU_DUE_TO_WRP = 2
 Int corrosponding to tau due to T_wrp.
 
int TAU_RESULTING = 3
 Int corrosponding to tau due to resulting tau.
 
int TAU_STV = 4
 Int corrosponding to tau due to T_stv.
 
int SIGMA_X_DUE_TO_N = 0
 Int corrosponding to sigma_x due to N.
 
int SIGMA_X_DUE_TO_MX = 1
 Int corrosponding to sigma_x due to Mx.
 
int SIGMA_X_DUE_TO_MY = 2
 Int corrosponding to sigma_x due to My.
 
int SIGMA_X_DUE_TO_B = 3
 Int corrosponding to sigma_x due to B.
 
int SIGMA_X_RESULTING = 4
 Int corrosponding to resulting sigma_x.
 
int EFFECTIVE_STRESS = 5
 Int corrosponding to resulting effective stress.
 
int OMEGA_DIAGRAM = 0
 Int corrosponding to omega diagram.
 
double anglePrincipalAxes
 Stores the angle of the principal axes in degrees.
 
double anglePrincipalAxesRad
 Stores the angle of the principal axes in radians.
 
double Ax
 
double Ay
 Area centre for mesh in X- and Y-direction.
 
double EA
 Axial stiffness.
 
double EIx
 
double EIy
 
double EIxy
 
double EImax
 Bending stiffness about global x- and y-axes.
 
double EIxp
 
double EIyp
 Bending stiffness about principal x- and y-axes.
 
double Sx
 
double Sy
 TODO.
 
double xs
 x-position of shear center
 
double ys
 y-position of hear center
 
double C
 Shear center constant.
 
double totalArea
 The sum of all element areas.
 
double areaStiffness
 Area stiffness EA.
 
double stVenantStiffness
 St.Venant stiffness GI_t.
 
double warpingStiffness
 Warping stiffness EI_.
 
double kappaX
 Shear deformation factor x.
 
double kappaY
 Shear deformation factor y.
 
double baseE = 210000
 Young's modulus of base material.
 
double baseG = 80770
 Shear modulus of base material.
 
double N
 Normal force to be applied to the cross section.
 
double Mx
 Bending moment in x-direction to be applied to the cross section.
 
double My
 Bending moment in y-direction to be applied to the cross section.
 
double Vx
 Shear force in x-direction to be applied to the cross section.
 
double Vy
 Shear force in y-direction to be applied to the cross section.
 
double Bi
 Bimoment to be applied to the cross section.
 
double T_stv
 St.Venant torsion to be applied to the cross section.
 
double T_wrp
 Warping torsion to be applied to the cross section.
 
int numberOfNodes
 Number of nodes in the cross-section.
 
int numberOfElementSegments
 Number of element segments along an element, used for displaying quadratic functions.
 
int numberOfExtraElementPoints
 Number of extra points along an element, used for displaying quadratic functions.
 
MatrixXd B
 Coefficiant matrix B is used to find st. venants stiffness.
 
VectorXd a
 A vector of doubles representing the areas of the cells found in the elements.
 
VectorXd p
 Modified shear flows around each cell.
 
MatrixXd D
 D matrix. More...
 
VectorXd f_d
 Vector containing input forces and moments \( f' = \begin{bmatrix} 0 & Vy & -Vx & -T_{wrp} \end{bmatrix} \).
 
VectorXd f_d_Vx
 Vector containing input forces and moments \( f'_{Vx} = \begin{bmatrix} 0 & 0 & -Vx & 0 \end{bmatrix} \).
 
VectorXd f_d_Vy
 Vector containing input forces and moments \( f'_{Vy} = \begin{bmatrix} 0 & Vy & 0 & 0 \end{bmatrix} \).
 
VectorXd f_d_Wrp
 Vector containing input forces and moments \( f'_{Wrp} = \begin{bmatrix} 0 & 0 & 0 & -T_{wrp} \end{bmatrix} \).
 
MatrixXd A1
 Matrix with directional \( \eta \) values. The matrix dimensions are [nrOfNodes x nrOfElements]. \( \eta \) is +1 if the LineElement direction is away from the node, and -1 if the direction is towards the node.
 
MatrixXd A2
 Matrix with directional \( \eta \) values. The matrix dimensions are [nrOfCells x nrOfElements]. \( \eta \) is +1 if the LineElement coincides with a positive counter clockwise direction of the cell, and -1 otherwise.
 
MatrixXd G1
 Matrix with G values, used to calculate q_0.
 
MatrixXd G2
 Matrix with G values, used to calculate q_0.
 
VectorXd q0
 Vector of shear flow in the middle of each element.
 
std::vector< LineElement * > elements
 List of all elements in mesh.
 
std::vector< Nodenodes
 List of all nodes in mesh.
 
std::vector< std::vector< LineElement * > > cycles
 2d vector containing all cycles in the cross-section
 
std::vector< LineElement * > orderedElements
 List of all elements ordered in a DFS manner.
 
std::vector< std::vector< double > > midPoints
 Vector containing the middle points of each elements.
 
std::vector< std::vector< std::vector< double > > > omegaIntersectionPoints
 Three dimensional vector containing intersection points for \( \omega \). More...
 
std::vector< std::vector< std::vector< double > > > sigmaXIntersectionPoints
 Three dimensional vector containing intersection points for \( \sigma_x \). More...
 
std::vector< std::vector< bool > > omegaIntersection
 Two dimensional vector containing boolean values if an element has an intersection of the omega diagram or not.
 
std::vector< double > extraPoint
 Vector of function values at points along the element, used for display of quadratic functions. The size of the vector is decided by numberOfElementSegments.
 
std::vector< double > tauIntersect
 Vector containing intersectionpoints of tau.
 
std::vector< std::vector< std::vector< double > > > tauIntersectionPoints
 Three dimensional vector containing intersection points for . More...
 
std::vector< std::vector< bool > > sigmaXIntersection
 Two dimensional vector containing boolean values if an element has an intersection or not. More...
 

Detailed Description

Contains mesh data and has function to calculate and retrieve mesh properties.

Member Function Documentation

void LineMesh::addElementPoints ( VectorXd  f_d,
int  type 
)

Adds points along the element used for visualization of quadratic functions.

Parameters
f_dvector used to find shear flow
typetype of load applied to cross-section
void LineMesh::calculateAnglePrincipalAxes ( )

Calculates angle of the principal axes.

\( t = \frac{-2EI_{xy}}{EI_x - EI_y} \)
\( \alpha = \frac{1}{2}\arctan(t)\frac{180}{\pi} \)

Returns
Angle of inertial axis.
void LineMesh::calculateAxialStress ( )

Calculates the resulting axial stress \( \sigma_x \) for all nodes in the cross-section, as well as axial stress due to N, Mx, My and B.

\( \begin{bmatrix} \frac{N}{EA} + \frac{M_x}{EI_x}y - \frac{M_y}{EI_y}x - \frac{B}{EI_\omega}\omega \end{bmatrix} \)

void LineMesh::calculateBendingStiffness ( )

Calculates seccond area moments.

Loops through all elements calculating the distance between mesh- and element area centres, and calculates the second moment of inertia for the mesh's x-, y- and xy-axis.

void LineMesh::calculateG1Matrix ( )

Calculates G1 matrix.

\( \textbf{g}_1 = \begin{bmatrix} \sum_{n_{i}} E_k t_k \frac{\Delta l_k}{2}\textbf{C}_{0k}^T - \sum_{n_{i}} \eta_k E_k t_k \frac{\Delta l_k}{8}\boldsymbol{\Delta}\textbf{C}_k^T \end{bmatrix} \textbf{D} \)

void LineMesh::calculateG2Matrix ( )

Calculates G2 matrix.

\( \textbf{g}_2 = - \begin{bmatrix} \sum_{n_{r}} \eta_k \frac{E_k \Delta l_k^2}{24G_k}\boldsymbol{\Delta}\textbf{C}_k^T \end{bmatrix} \textbf{D} \)

void LineMesh::calculateKappaX ( )

Calculates shear deformation factor x.

\( \kappa_x = (GA)\sum_k \begin{bmatrix} \left (\frac{\Delta x_k}{\Delta L_k} \right)^2 \frac{t_k}{G_k} \int _{s_k} (\tau^2 |_{V_x = 1}) ds \end{bmatrix} \)

void LineMesh::calculateKappaY ( )

Calculates shear deformation factor y.

\( \kappa_y = (GA)\sum_k \begin{bmatrix} \left (\frac{\Delta y_k}{\Delta L_k} \right)^2 \frac{t_k}{G_k} \int _{s_k} (\tau^2 |_{V_y = 1}) ds \end{bmatrix} \)

void LineMesh::calculateMeshProperties ( )

Calculates mesh properties.

The function is run by constructor. It runs through all elements calculating element areas and element centres for each element.
It also calculates total area of mesh, and area centre of the mesh using
\( A_x = \sum{( \frac{dx_e*a_e}{A}) } \) and \( A_y = \sum{ (\frac{dy_e*a_e}{A}) } \)

void LineMesh::calculateNodalTau ( VectorXd  f_d,
int  type 
)

Calculates tau values for the nodes.

Parameters
f_dvector used to find shear flow
typetype of load applied to cross-section
void LineMesh::calculateOmega_c ( )

Calculates \( \omega_c \) for all the elements.

Assigns \( \omega_{c1} \) = 0 to point number one. The rest of the \( \omega_c \) values are then calculated from \( \Delta \omega_c = \omega_{c2} - \omega_{c1} \), where \( \Delta \omega_c \) is found in advance and \(\omega_{c1} , \omega_{c2} \) are the values for node 1 and 2 in the element. To ensure that the calculation always have two known values, the elements are traversed in a DFS fashion.

void LineMesh::calculateOmegaIntersection ( int  type,
std::vector< std::vector< std::vector< double >>> *  intersectionPoints,
std::vector< std::vector< bool >> *  intersection 
)

Iterates through all elements and finds sigma_x intersection values for omega diagrams if they exist.

Parameters
typedescribes the type of force applied to the cross section
*intersectionPointsa 3d vector of doubles containing intersection points
*intersectiona 2d vector containing boolean values if an element has an intersection point
void LineMesh::calculatePureStvTorsionStress ( )

Calculates the pure St.Venants torsion stress.

q_{k,stv} = {2 T_{stv} {q}_k}{GI_t}

void LineMesh::calculateQ0 ( VectorXd  f_d,
int  type 
)

Calculates q0.

by solving the equation \( \begin{bmatrix} \textbf{A}_1 \\ \textbf{A}_2 \end{bmatrix} \textbf{q}_0 = \begin{bmatrix} \textbf{g}_1 \\ \textbf{g}_2 \end{bmatrix} \textbf{f'} \)

To solve the equation Eigen's ColPivHouseholderQR solver is used

Parameters
f_dVector used in calculation of q0
typeof force applied
double LineMesh::calculateQs ( double  s,
LineElement element,
VectorXd  f_d,
int  type 
)

Calculates the shear value at a distance s along the element.

Parameters
sposition along the element, goes from -1 to 1
elementthe element in question
f_dvector used in calculation of q
typetype of force applied to cross-section
Returns
double value of q at a distance s along the element
void LineMesh::calculateSigmaXIntersection ( int  type,
std::vector< std::vector< std::vector< double >>> *  intersectionPoints,
std::vector< std::vector< bool >> *  intersection 
)

Iterates through all elements and finds /f$ /f$ intersection values if they exist.

Parameters
typedescribes the type of force applied to the cross section
*intersectionPointsa 3d vector of doubles containing intersection points
*intersectiona 2d vector containing boolean values if an element has an intersection point
void LineMesh::calculateStVenantStiffness ( CycleDetection  c)

Calculates the St.Venant stiffness \( GI_t \).

\( GI_t = 4 \boldsymbol{p}^T \boldsymbol{a} + \frac{1}{3} \sum\limits_{k=1}^{n_f} G_k t_k^3 \Delta l_k \) where \( n_f \) is the number of open elements

Parameters
ccycle detection object, needed to get all the open elements of the cross-section
void LineMesh::calculateTau ( VectorXd  f_d,
int  type 
)

Calculates tau for different applied loads.

Parameters
f_dvector used in calculation of tau
typetype of force applied to cross-section
double LineMesh::calculateVonMisesStress ( LineElement element,
int  j 
)

Calculates von mises stress.

\( \sigma_y = \sqrt{\sigma_x^2 + 3 \tau^2} \)

Returns
von Mises stress ( \(\sigma_y\))
void LineMesh::constructAVector ( CycleDetection  c)

Constructs area vector a.

This method constructs the a vector that is used to solve for shear flows. The vector consists of the areas of all the cells in the cross-section

Parameters
cCycleDetection object
void LineMesh::constructBMatrix ( )

Constructs coefficiant matrix \( \textbf{B} \).

This method constructs the \( \textbf{B} \) matrix that is used to solve for shear flows. The diagonal is found by taking \( B_{rr} = \sum_{k=1}^{n_{rr}}\frac{\Delta l_k}{G_k t_k} \) where \( n_{rr} \) is all the elements of cell r. The off diagonals are found by \( B_{rs} = \sum_{k=1}^{n_{rs}}\frac{\Delta l_k}{G_k t_k} \) where \( n_{rs} \) is the number of common elements of cells r and s. If there are no common elements, the corrosponding coefficiant is 0.

bool LineMesh::contains ( std::vector< int >  a,
int  b 
)

Checks wether a vector of ints contains a certain int, could be placed in a UTILS class.

Parameters
avector of ints
bint
Returns
true if vector a contains int b, false if not
void LineMesh::createA1Matrix ( )

Creates A1 matrix.

The matrix dimensions are [nrOfNodes x nrOfElements]. \( %eta \) is +1 if the LineElement direction is away from the node, and -1 if the direction is towards the node.

void LineMesh::createA2Matrix ( )

Creates A2 matrix.

The matrix dimensions are [nrOfCells x nrOfElements]. \( %eta \) is +1 if the LineElement coincides with a positive counter clockwise direction of the cell, and -1 otherwise.

std::vector< LineElement * > LineMesh::DFS ( )

Creates a vector of LineElement pointers that are sorted in a DFS fashion, could be extracted to a UTILS class.

Returns
vector of LineElements ordered after their appearence in DFS search
std::vector< LineElement * > LineMesh::findCommonElements ( std::vector< LineElement * >  a,
std::vector< LineElement * >  b 
)

Finds common elements in two vectors, could be moved to a UTILS class.

Parameters
avector one
bvector two
Returns
vector of common elements in list a and b
void LineMesh::findElementIntersections ( VectorXd  f_d,
int  type 
)

Finds the element intersection points for quadratic functions along the element.

Parameters
f_dvector used to find shear flow
typetype of load applied to cross-section
void LineMesh::initializeMatrices ( )

Initializes matrices.

\( f' = \begin{bmatrix} 0 & Vy & -Vx & -T_{wrp} \end{bmatrix} f'_{Vy} = \begin{bmatrix} 0 & Vy & 0 & 0 \end{bmatrix} f'_{Vx} = \begin{bmatrix} 0 & 0 & -Vx & 0 \end{bmatrix} f'_{Wrp} = \begin{bmatrix} 0 & 0 & 0 & -T_{wrp} \end{bmatrix} \)

\( \textbf{D} = \begin{bmatrix} \frac{1}{EA} & 0 & 0 & 0\\ 0& \frac{1}{EI_x} & 0 & 0\\ 0 &0 & \frac{1}{EI_y} & 0\\ 0 & 0 & 0 & \frac{1}{EI_{\omega}} \end{bmatrix} \)

void LineMesh::initiateCVectors ( )

Initializes the C vectors for each element.

\( \textbf{c}_0^T = \begin{bmatrix} 1 & y_0 & x_0 & \omega_0 \end{bmatrix} \) \( \boldsymbol{\Delta}\textbf{c}_0^T = \begin{bmatrix} 0 & \Delta y & \Delta x & \Delta \omega \end{bmatrix} \)

void LineMesh::printEigenMatrix ( MatrixXd  A,
std::string  s 
)

prints out a matrix on Eigen format

Parameters
AEigen matrix
sName of the matrix
void LineMesh::solveSystemEquation ( )

Solves the system of equations.

This method solves the system of equations /f$ {B} {p} = {a} /f$, where the shear flows /f$ {p} /f$ are unknowns, /f$ {a} /f$ are the cell areas, and /f$ {B} /f$ is a coefficiant matrix

void LineMesh::transformCoordinates ( )

Transforms coordinates for computation purposes.

\( x' = (x-A_x)cos(\alpha) + (y-A_y)sin(\alpha) \)
\( x' = (y-A_y)cos(\alpha) - (x-A_x)sin(\alpha) \)

Member Data Documentation

MatrixXd LineMesh::D

D matrix.

\( \textbf{D} = \begin{bmatrix} \frac{1}{EA} & 0 & 0 & 0\\ 0& \frac{1}{EI_x} & 0 & 0\\ 0 &0 & \frac{1}{EI_y} & 0\\ 0 & 0 & 0 & \frac{1}{EI_{\omega}} \end{bmatrix} \)

std::vector<std::vector<std::vector<double> > > LineMesh::omegaIntersectionPoints

Three dimensional vector containing intersection points for \( \omega \).

The three dimensional vector is formatted in the following way:

Intersection points = \( \begin{bmatrix} \omega\\ \end{bmatrix} = \begin{bmatrix} (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ \end{bmatrix} \)

std::vector<std::vector<bool> > LineMesh::sigmaXIntersection

Two dimensional vector containing boolean values if an element has an intersection or not.

The two dimensional vector is formatted in the following way:

\( \begin{bmatrix} \sigma_{x,N}\\ \sigma_{x,Mx}\\ \sigma_{x,My}\\ \sigma_{x,B}\\ \sigma_{x,Resulting} \end{bmatrix} = \begin{bmatrix} false & true & ... & true \\ true & true & ... & true \\ false & false & ... & false \\ flase & false & ... & true \\ false & false & ... & false \\ \end{bmatrix} \)

std::vector<std::vector<std::vector<double> > > LineMesh::sigmaXIntersectionPoints

Three dimensional vector containing intersection points for \( \sigma_x \).

The three dimensional vector is formatted in the following way:

Intersection points = \( \begin{bmatrix} \sigma_{x,N}\\ \sigma_{x,Mx}\\ \sigma_{x,My}\\ \sigma_{x,B}\\ \sigma_{x,Resulting} \end{bmatrix} = \begin{bmatrix} (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ \end{bmatrix} \)

std::vector<std::vector<std::vector<double> > > LineMesh::tauIntersectionPoints

Three dimensional vector containing intersection points for .

The three dimensional vector is formatted in the following way:

Intersection points = \( \begin{bmatrix} \tau_{Vx}\\ \tau_{Vy}\\ \tau_{T_{wrp}}\\ \tau_{resulting}\\ \tau_{T_{stv}} \end{bmatrix} = \begin{bmatrix} (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ (x_1, y_1) & (x_2, y_2) & ... & (x_n, y_n)) \\ \end{bmatrix} \)


The documentation for this class was generated from the following files: