FullVector
The `FullVector` component in the SOFA framework is a templated class that provides an implementation for dense vectors used in linear algebra operations. It inherits from `BaseVector`, which suggests it adheres to a common interface for vector operations within SOFA. The `FullVector` class supports various operations such as resizing, accessing elements, and performing arithmetic operations like addition, subtraction, scalar multiplication, and dot product calculations. ### Role in the SOFA Ecosystem: The `FullVector` is an essential component for numerical computations involving vectors, particularly for linear algebra tasks within simulation algorithms. It ensures that vector operations are performed efficiently and correctly, making it a fundamental building block for various solvers and simulation components within SOFA. ### Interactions with Other Components: The `FullVector` interacts primarily with other linear algebra components through its methods that handle resizing, accessing elements, and performing arithmetic operations. These interactions are critical for setting up and solving systems of equations in simulations. The class also adheres to the `BaseVector` interface, facilitating interoperability with other vector types within SOFA. ### Practical Usage Guidance: The `FullVector` can be instantiated with different numeric types (`float`, `double`). It provides methods like `resize`, `clear`, and arithmetic operators that make it easy to manipulate vectors. The `ptr` method allows direct access to the underlying array, which is useful for low-level memory operations or interfacing with external libraries. ### Data Fields: The component does not have explicit data fields in its API metadata but internally uses a raw pointer (`data`) and two size indices (`cursize`, `allocsize`) to manage its state. These internal members are used to track the current size of the vector, the allocated memory size, and provide direct access to the elements.
- abstract
- `FullVector` provides dense vector operations for linear algebra tasks within the SOFA framework, supporting resizing, element access, arithmetic operations, and memory management.
- sheet
- # FullVector ## Overview The `FullVector` component in the SOFA framework is a templated class that implements dense vectors used in linear algebra operations. It inherits from `BaseVector`, ensuring compatibility with other vector types within SOFA. The component supports various methods for resizing, accessing elements, and performing arithmetic operations such as addition, subtraction, scalar multiplication, and dot product calculations. ## Parameters and Data The `FullVector` class does not have explicit data fields in its API metadata but internally uses a raw pointer (`data`) and two size indices (`cursize`, `allocsize`) to manage its state. These internal members are used to track the current size of the vector, the allocated memory size, and provide direct access to the elements. - **`ptr()`**: Returns a pointer to the underlying array of elements. - **`setptr(T *p)`**: Sets the pointer to the underlying array of elements. - **`capacity()`**: Returns the allocated capacity of the vector. - **`begin()`**: Returns an iterator pointing to the first element. - **`end()`**: Returns an iterator pointing past the last element. - **`fastResize(Index dim)`**: Resizes the vector without preserving existing elements. - **`resize(Index dim)`**: Resizes the vector, preserving existing elements if possible. - **`clear()`**: Clears the vector and deallocates memory. - **`swap(FullVector<T> &v)`**: Swaps the contents with another `FullVector` instance. - **`operator[](Index i)`**: Returns a reference to the element at index `i`. - **`element(Index i)`**: Returns the element at index `i` as a `SReal` type. - **`set(Index i, SReal v)`**: Sets the value of the element at index `i`. - **`add(Index i, SReal v)`**: Adds a value to the element at index `i`. - **`size()`**: Returns the current size of the vector. - **`sub(Index i, Index n)`**: Returns a subvector starting from index `i` with length `n`. - **`getsub(Index i, Index n, TV &v)`**: Copies elements from index `i` to `v`, with length `n`. - **`setsub(Index i, Index n, const TV &v)`**: Sets elements starting from index `i` using values from `v`, with length `n`. - **`operator=(const FullVector<T> &a)`**: Assigns the contents of another `FullVector` instance to this vector. - **`operator=(const T &a)`**: Assigns a scalar value to all elements in the vector. - **`operator+=(const FullVector<Real> &a)`**: Adds another vector element-wise. - **`operator-=(const FullVector<Real> &a)`**: Subtracts another vector element-wise. - **`eq(const FullVector<Real> &a, Real f)`**: Sets the vector to `f * a`. - **`eq(const FullVector<Real> &a, const FullVector<Real> &b, Real f)`**: Sets the vector to `a + b * f`. - **`peq(const FullVector<Real> &a, Real f)`**: Adds `f * a` element-wise to this vector. - **`operator*=(Real f)`**: Multiplies all elements by a scalar value `f`. - **`dot(const FullVector<Real> &a)`**: Computes the dot product with another vector. - **`norm()`**: Computes the Euclidean norm (L2-norm) of the vector.
- description
- The `FullVector` component in the SOFA framework is a templated class that provides an implementation for dense vectors used in linear algebra operations. It inherits from `BaseVector`, which suggests it adheres to a common interface for vector operations within SOFA. The `FullVector` class supports various operations such as resizing, accessing elements, and performing arithmetic operations like addition, subtraction, scalar multiplication, and dot product calculations. ### Role in the SOFA Ecosystem: The `FullVector` is an essential component for numerical computations involving vectors, particularly for linear algebra tasks within simulation algorithms. It ensures that vector operations are performed efficiently and correctly, making it a fundamental building block for various solvers and simulation components within SOFA. ### Interactions with Other Components: The `FullVector` interacts primarily with other linear algebra components through its methods that handle resizing, accessing elements, and performing arithmetic operations. These interactions are critical for setting up and solving systems of equations in simulations. The class also adheres to the `BaseVector` interface, facilitating interoperability with other vector types within SOFA. ### Practical Usage Guidance: The `FullVector` can be instantiated with different numeric types (`float`, `double`). It provides methods like `resize`, `clear`, and arithmetic operators that make it easy to manipulate vectors. The `ptr` method allows direct access to the underlying array, which is useful for low-level memory operations or interfacing with external libraries. ### Data Fields: The component does not have explicit data fields in its API metadata but internally uses a raw pointer (`data`) and two size indices (`cursize`, `allocsize`) to manage its state. These internal members are used to track the current size of the vector, the allocated memory size, and provide direct access to the elements.
- maths
- The `FullVector` class in the SOFA framework is designed to represent dense vectors commonly used in numerical linear algebra. It provides a comprehensive set of operations for manipulating and performing arithmetic with vector data. Below, we detail the mathematical and physical aspects related to this component. ### Mathematical Description: #### 1. **Dense Vector Representation:** `FullVector<T>` is a templated class that can store vectors with elements of type `T`, where `T` is typically a numeric type such as `float` or `double`. The internal representation uses a contiguous block of memory to hold the vector elements, allowing efficient access and manipulation. #### 2. **Element Access:** Elements in the vector are accessed via index-based operations. For an instance `v` of `FullVector<T>`, the element at position `i` can be retrieved using: \[ v[i] \] The method `element(Index i)` returns the element at index `i` as a `SReal` type, which is typically used for floating-point operations. #### 3. **Arithmetic Operations:** - **Scalar Multiplication (Scaling):** A vector `v` can be scaled by a scalar `f`. If `a` and `b` are vectors of the same length: \[ v = f \cdot a \] This operation is implemented in the method `eq(const FullVector<T>& a, Real f)`. - **Addition:** Two vectors `v` and `a` can be added element-wise. If `b` is another vector of the same length: \[ v = v + a \] or \[ v = a + b \cdot f \] These operations are implemented using methods like `operator+=()` and `eq(const FullVector<T>& a, const FullVector<T>& b, Real f)`. - **Subtraction:** Similarly, vectors can be subtracted element-wise: \[ v = v - a \] or \[ v = a - b \cdot f \] implemented using methods like `operator-=()` and `eq(const FullVector<T>& a, const FullVector<T>& b, Real f)`. - **Dot Product:** The dot product between two vectors `v` and `a` is calculated as: \[ v ullet a = \sum_{i=1}^{n} (v[i] imes a[i]) \] implemented in the method `dot(const FullVector<T>& a)`. - **Norm Calculation:** The Euclidean norm (L2-norm) of vector `v` is calculated as: \[ ||v||_2 = \sqrt{\sum_{i=1}^{n} v[i]^2} \] implemented in the method `norm()`. #### 4. **Memory Management:** The class manages memory for storing elements through methods like `resize`, `fastResize`, and a destructor that frees allocated memory if necessary. The size of the vector is tracked by `cursize` (current size) and `allocsize` (allocated size). ### Physical Description: In the context of physical simulations, vectors often represent quantities such as displacements, velocities, or forces. The operations provided by `FullVector` enable efficient manipulation and computation of these physical quantities. - **Displacement Vectors:** In mechanics, displacement vectors describe the change in position of a body. Operations like addition and subtraction are used to compute resultant displacements under different force scenarios. - **Velocity and Force Vectors:** Velocity and force vectors can be manipulated using scaling operations to represent changes due to external forces or accelerations. - **Dot Product for Work Calculation:** The dot product is crucial in calculating work done by a force acting on an object. It provides the component of one vector along the direction of another, allowing computation of energy transfer between interacting bodies. - **Norms for Magnitude Calculations:** Norm calculations are used to determine magnitudes such as the speed of an object from its velocity vector or the magnitude of a force vector. In summary, `FullVector` provides essential operations for dense vector manipulations in numerical linear algebra and physical simulations. Its methods enable efficient computation of various quantities necessary for accurate and performant simulation algorithms.
{
"name": "FullVector",
"main": {
"name": "FullVector",
"namespace": "sofa::linearalgebra",
"module": "Sofa.framework.LinearAlgebra",
"include": "sofa/linearalgebra/FullVector.h",
"doc": "",
"inherits": [
"BaseVector"
],
"templates": [
"double",
"float"
],
"data_fields": [],
"links": [],
"methods": [
{
"name": "checkIndex",
"return_type": "void",
"params": [
{
"name": "n",
"type": "Index"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "protected"
},
{
"name": "ptr",
"return_type": "T *",
"params": [],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "setptr",
"return_type": "void",
"params": [
{
"name": "p",
"type": "T *"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "capacity",
"return_type": "Index",
"params": [],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "begin",
"return_type": "Iterator",
"params": [],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "end",
"return_type": "Iterator",
"params": [],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "fastResize",
"return_type": "void",
"params": [
{
"name": "dim",
"type": "Index"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "resize",
"return_type": "void",
"params": [
{
"name": "dim",
"type": "Index"
}
],
"is_virtual": true,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "clear",
"return_type": "void",
"params": [],
"is_virtual": true,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "swap",
"return_type": "void",
"params": [
{
"name": "v",
"type": "FullVector<T> &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "clear",
"return_type": "void",
"params": [
{
"name": "dim",
"type": "Index"
}
],
"is_virtual": true,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "operator[]",
"return_type": "T &",
"params": [
{
"name": "i",
"type": "Index"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "element",
"return_type": "SReal",
"params": [
{
"name": "i",
"type": "Index"
}
],
"is_virtual": true,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "set",
"return_type": "void",
"params": [
{
"name": "i",
"type": "Index"
},
{
"name": "v",
"type": "SReal"
}
],
"is_virtual": true,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "add",
"return_type": "void",
"params": [
{
"name": "i",
"type": "Index"
},
{
"name": "v",
"type": "SReal"
}
],
"is_virtual": true,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "size",
"return_type": "Index",
"params": [],
"is_virtual": true,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "sub",
"return_type": "FullVector<T>",
"params": [
{
"name": "i",
"type": "Index"
},
{
"name": "n",
"type": "Index"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "getsub",
"return_type": "void",
"params": [
{
"name": "i",
"type": "Index"
},
{
"name": "n",
"type": "Index"
},
{
"name": "v",
"type": "TV &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "setsub",
"return_type": "void",
"params": [
{
"name": "i",
"type": "Index"
},
{
"name": "n",
"type": "Index"
},
{
"name": "v",
"type": "const TV &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "operator=",
"return_type": "void",
"params": [
{
"name": "a",
"type": "const FullVector<T> &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "operator=",
"return_type": "void",
"params": [
{
"name": "a",
"type": "const T &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "operator+=",
"return_type": "void",
"params": [
{
"name": "a",
"type": "const FullVector<Real> &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "operator-=",
"return_type": "void",
"params": [
{
"name": "a",
"type": "const FullVector<Real> &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "eq",
"return_type": "void",
"params": [
{
"name": "a",
"type": "const FullVector<Real> &"
},
{
"name": "f",
"type": "Real"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "eq",
"return_type": "void",
"params": [
{
"name": "a",
"type": "const FullVector<Real> &"
},
{
"name": "b",
"type": "const FullVector<Real> &"
},
{
"name": "f",
"type": "Real"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "peq",
"return_type": "void",
"params": [
{
"name": "a",
"type": "const FullVector<Real> &"
},
{
"name": "f",
"type": "Real"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "operator*=",
"return_type": "void",
"params": [
{
"name": "f",
"type": "Real"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "dot",
"return_type": "Real",
"params": [
{
"name": "a",
"type": "const FullVector<Real> &"
}
],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "norm",
"return_type": "double",
"params": [],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": false,
"access": "public"
},
{
"name": "Name",
"return_type": "const char *",
"params": [],
"is_virtual": false,
"is_pure_virtual": false,
"is_static": true,
"access": "public"
}
]
},
"desc": {
"description": "The `FullVector` component in the SOFA framework is a templated class that provides an implementation for dense vectors used in linear algebra operations. It inherits from `BaseVector`, which suggests it adheres to a common interface for vector operations within SOFA. The `FullVector` class supports various operations such as resizing, accessing elements, and performing arithmetic operations like addition, subtraction, scalar multiplication, and dot product calculations.\n\n### Role in the SOFA Ecosystem:\nThe `FullVector` is an essential component for numerical computations involving vectors, particularly for linear algebra tasks within simulation algorithms. It ensures that vector operations are performed efficiently and correctly, making it a fundamental building block for various solvers and simulation components within SOFA.\n\n### Interactions with Other Components:\nThe `FullVector` interacts primarily with other linear algebra components through its methods that handle resizing, accessing elements, and performing arithmetic operations. These interactions are critical for setting up and solving systems of equations in simulations. The class also adheres to the `BaseVector` interface, facilitating interoperability with other vector types within SOFA.\n\n### Practical Usage Guidance:\nThe `FullVector` can be instantiated with different numeric types (`float`, `double`). It provides methods like `resize`, `clear`, and arithmetic operators that make it easy to manipulate vectors. The `ptr` method allows direct access to the underlying array, which is useful for low-level memory operations or interfacing with external libraries.\n\n### Data Fields:\nThe component does not have explicit data fields in its API metadata but internally uses a raw pointer (`data`) and two size indices (`cursize`, `allocsize`) to manage its state. These internal members are used to track the current size of the vector, the allocated memory size, and provide direct access to the elements."
},
"maths": {
"maths": "The `FullVector` class in the SOFA framework is designed to represent dense vectors commonly used in numerical linear algebra. It provides a comprehensive set of operations for manipulating and performing arithmetic with vector data. Below, we detail the mathematical and physical aspects related to this component.\n\n### Mathematical Description:\n\n#### 1. **Dense Vector Representation:**\n`FullVector<T>` is a templated class that can store vectors with elements of type `T`, where `T` is typically a numeric type such as `float` or `double`. The internal representation uses a contiguous block of memory to hold the vector elements, allowing efficient access and manipulation.\n\n#### 2. **Element Access:**\nElements in the vector are accessed via index-based operations. For an instance `v` of `FullVector<T>`, the element at position `i` can be retrieved using:\n\\[ v[i] \\]\nThe method `element(Index i)` returns the element at index `i` as a `SReal` type, which is typically used for floating-point operations.\n\n#### 3. **Arithmetic Operations:**\n- **Scalar Multiplication (Scaling):** A vector `v` can be scaled by a scalar `f`. If `a` and `b` are vectors of the same length:\n\\[ v = f \\cdot a \\]\nThis operation is implemented in the method `eq(const FullVector<T>& a, Real f)`.\n\n- **Addition:** Two vectors `v` and `a` can be added element-wise. If `b` is another vector of the same length:\n\\[ v = v + a \\]\nor \n\\[ v = a + b \\cdot f \\]\nThese operations are implemented using methods like `operator+=()` and `eq(const FullVector<T>& a, const FullVector<T>& b, Real f)`.\n\n- **Subtraction:** Similarly, vectors can be subtracted element-wise:\n\\[ v = v - a \\]\nor \n\\[ v = a - b \\cdot f \\]\nimplemented using methods like `operator-=()` and `eq(const FullVector<T>& a, const FullVector<T>& b, Real f)`.\n\n- **Dot Product:** The dot product between two vectors `v` and `a` is calculated as:\n\\[ v \bullet a = \\sum_{i=1}^{n} (v[i] \times a[i]) \\]\nimplemented in the method `dot(const FullVector<T>& a)`.\n\n- **Norm Calculation:** The Euclidean norm (L2-norm) of vector `v` is calculated as:\n\\[ ||v||_2 = \\sqrt{\\sum_{i=1}^{n} v[i]^2} \\]\nimplemented in the method `norm()`.\n\n#### 4. **Memory Management:**\nThe class manages memory for storing elements through methods like `resize`, `fastResize`, and a destructor that frees allocated memory if necessary. The size of the vector is tracked by `cursize` (current size) and `allocsize` (allocated size). \n\n### Physical Description:\nIn the context of physical simulations, vectors often represent quantities such as displacements, velocities, or forces. The operations provided by `FullVector` enable efficient manipulation and computation of these physical quantities.\n\n- **Displacement Vectors:** In mechanics, displacement vectors describe the change in position of a body. Operations like addition and subtraction are used to compute resultant displacements under different force scenarios.\n\n- **Velocity and Force Vectors:** Velocity and force vectors can be manipulated using scaling operations to represent changes due to external forces or accelerations.\n\n- **Dot Product for Work Calculation:** The dot product is crucial in calculating work done by a force acting on an object. It provides the component of one vector along the direction of another, allowing computation of energy transfer between interacting bodies.\n\n- **Norms for Magnitude Calculations:** Norm calculations are used to determine magnitudes such as the speed of an object from its velocity vector or the magnitude of a force vector.\n\nIn summary, `FullVector` provides essential operations for dense vector manipulations in numerical linear algebra and physical simulations. Its methods enable efficient computation of various quantities necessary for accurate and performant simulation algorithms."
},
"summary": {
"abstract": "`FullVector` provides dense vector operations for linear algebra tasks within the SOFA framework, supporting resizing, element access, arithmetic operations, and memory management.",
"sheet": "# FullVector\n\n## Overview\n\nThe `FullVector` component in the SOFA framework is a templated class that implements dense vectors used in linear algebra operations. It inherits from `BaseVector`, ensuring compatibility with other vector types within SOFA. The component supports various methods for resizing, accessing elements, and performing arithmetic operations such as addition, subtraction, scalar multiplication, and dot product calculations.\n\n## Parameters and Data\n\nThe `FullVector` class does not have explicit data fields in its API metadata but internally uses a raw pointer (`data`) and two size indices (`cursize`, `allocsize`) to manage its state. These internal members are used to track the current size of the vector, the allocated memory size, and provide direct access to the elements.\n\n- **`ptr()`**: Returns a pointer to the underlying array of elements.\n- **`setptr(T *p)`**: Sets the pointer to the underlying array of elements.\n- **`capacity()`**: Returns the allocated capacity of the vector.\n- **`begin()`**: Returns an iterator pointing to the first element.\n- **`end()`**: Returns an iterator pointing past the last element.\n- **`fastResize(Index dim)`**: Resizes the vector without preserving existing elements.\n- **`resize(Index dim)`**: Resizes the vector, preserving existing elements if possible.\n- **`clear()`**: Clears the vector and deallocates memory.\n- **`swap(FullVector<T> &v)`**: Swaps the contents with another `FullVector` instance.\n- **`operator[](Index i)`**: Returns a reference to the element at index `i`.\n- **`element(Index i)`**: Returns the element at index `i` as a `SReal` type.\n- **`set(Index i, SReal v)`**: Sets the value of the element at index `i`.\n- **`add(Index i, SReal v)`**: Adds a value to the element at index `i`.\n- **`size()`**: Returns the current size of the vector.\n- **`sub(Index i, Index n)`**: Returns a subvector starting from index `i` with length `n`.\n- **`getsub(Index i, Index n, TV &v)`**: Copies elements from index `i` to `v`, with length `n`.\n- **`setsub(Index i, Index n, const TV &v)`**: Sets elements starting from index `i` using values from `v`, with length `n`.\n- **`operator=(const FullVector<T> &a)`**: Assigns the contents of another `FullVector` instance to this vector.\n- **`operator=(const T &a)`**: Assigns a scalar value to all elements in the vector.\n- **`operator+=(const FullVector<Real> &a)`**: Adds another vector element-wise.\n- **`operator-=(const FullVector<Real> &a)`**: Subtracts another vector element-wise.\n- **`eq(const FullVector<Real> &a, Real f)`**: Sets the vector to `f * a`.\n- **`eq(const FullVector<Real> &a, const FullVector<Real> &b, Real f)`**: Sets the vector to `a + b * f`.\n- **`peq(const FullVector<Real> &a, Real f)`**: Adds `f * a` element-wise to this vector.\n- **`operator*=(Real f)`**: Multiplies all elements by a scalar value `f`.\n- **`dot(const FullVector<Real> &a)`**: Computes the dot product with another vector.\n- **`norm()`**: Computes the Euclidean norm (L2-norm) of the vector."
}
}