Stay organized with collections
Save and categorize content based on your preferences.
C++ Reference: class LatticeMemoryManager
Note: This documentation is automatically generated.
| Method |
BaseOffset | Return type: inline uint64_t Arguments: int card, Set s Returns the base offset in memory for f(s, node), with node contained in s.
This is useful in the Dynamic Programming iterations.
Note(user): inlining this function gains about 5%.
TODO(user): Investigate how to compute BaseOffset(card - 1, s \ { n })
from BaseOffset(card, n) to speed up the DP iteration.
|
Init | Return type: void Arguments: int max_card Reserves memory and fills in the data necessary to access memory.
|
LatticeMemoryManager | |
Offset | Return type: uint64_t Arguments: Set s, int node Returns the offset in memory for f(s, node), with node contained in s.
|
OffsetDelta | Return type: uint64_t Arguments: int card, int added_node, int removed_node,
int rank Returns the offset delta for a set of cardinality 'card', to which
node 'removed_node' is replaced by 'added_node' at 'rank'
|
SetValue | Return type: void Arguments: Set s, int node, CostType value Memorizes the value = f(s, node) at the correct offset.
This is favored in all other uses than the Dynamic Programming iterations.
|
SetValueAtOffset | Return type: void Arguments: uint64_t offset, CostType value Memorizes 'value' at 'offset'. This is useful in the Dynamic Programming
iterations where we want to avoid compute the offset of a pair (set, node).
|
Value | Return type: CostType Arguments: Set s, int node Returns the memorized value f(s, node) with node in s.
This is favored in all other uses than the Dynamic Programming iterations.
|
ValueAtOffset | Return type: CostType Arguments: uint64_t offset Returns the memorized value at 'offset'.
This is useful in the Dynamic Programming iterations.
|
Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.
Last updated 2024-08-06 UTC.
[null,null,["Last updated 2024-08-06 UTC."],[[["\u003cp\u003e\u003ccode\u003eLatticeMemoryManager\u003c/code\u003e is a C++ class designed for efficient memory management in dynamic programming algorithms, particularly for Hamiltonian path problems.\u003c/p\u003e\n"],["\u003cp\u003eIt provides methods for calculating memory offsets, storing and retrieving values associated with sets and nodes, crucial for the Held-Karp algorithm.\u003c/p\u003e\n"],["\u003cp\u003eMethods like \u003ccode\u003eOffset\u003c/code\u003e, \u003ccode\u003eBaseOffset\u003c/code\u003e, and \u003ccode\u003eOffsetDelta\u003c/code\u003e are optimized for quick access to data during DP iterations, improving performance.\u003c/p\u003e\n"],["\u003cp\u003e\u003ccode\u003eSetValue\u003c/code\u003e and \u003ccode\u003eValue\u003c/code\u003e offer general access, while \u003ccode\u003eSetValueAtOffset\u003c/code\u003e and \u003ccode\u003eValueAtOffset\u003c/code\u003e are optimized for use within dynamic programming loops.\u003c/p\u003e\n"],["\u003cp\u003eThe class requires initialization via \u003ccode\u003eInit\u003c/code\u003e to allocate and prepare the memory structure before use.\u003c/p\u003e\n"]]],["The `LatticeMemoryManager` class manages memory for storing values related to sets and nodes. Key actions include: initializing memory with `Init`, retrieving memory offsets with `Offset` and `BaseOffset`, and calculating offset changes using `OffsetDelta`. Values are stored and retrieved using `SetValue`, `SetValueAtOffset`, `Value`, and `ValueAtOffset`. These methods handle the dynamic programming iterations and other memory access, providing the ability to store and recall calculated results at given memory offsets.\n"],null,["# LatticeMemoryManager\n\nC++ Reference: class LatticeMemoryManager\n=========================================\n\n\nNote: This documentation is automatically generated.\n\n| Method ||\n|--------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [`BaseOffset`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L307) | Return type: `inline uint64_t ` Arguments: `int card, Set s` Returns the base offset in memory for f(s, node), with node contained in s. This is useful in the Dynamic Programming iterations. Note(user): inlining this function gains about 5%. TODO(user): Investigate how to compute BaseOffset(card - 1, s \\\\ { n }) from BaseOffset(card, n) to speed up the DP iteration. |\n| [`Init`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L297) | Return type: `void ` Arguments: `int max_card` Reserves memory and fills in the data necessary to access memory. |\n| [`LatticeMemoryManager`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L294) | \u003cbr /\u003e |\n| [`Offset`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L300) | Return type: `uint64_t ` Arguments: `Set s, int node` Returns the offset in memory for f(s, node), with node contained in s. |\n| [`OffsetDelta`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L311) | Return type: `uint64_t ` Arguments: `int card, int added_node, int removed_node, int rank` Returns the offset delta for a set of cardinality 'card', to which node 'removed_node' is replaced by 'added_node' at 'rank' |\n| [`SetValue`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L320) | Return type: `void ` Arguments: `Set s, int node, CostType value` Memorizes the value = f(s, node) at the correct offset. This is favored in all other uses than the Dynamic Programming iterations. |\n| [`SetValueAtOffset`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L324) | Return type: `void ` Arguments: `uint64_t offset, CostType value` Memorizes 'value' at 'offset'. This is useful in the Dynamic Programming iterations where we want to avoid compute the offset of a pair (set, node). |\n| [`Value`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L330) | Return type: `CostType ` Arguments: `Set s, int node` Returns the memorized value f(s, node) with node in s. This is favored in all other uses than the Dynamic Programming iterations. |\n| [`ValueAtOffset`](https://github.com/google/or-tools/blob/v9.4/ortools/graph/hamiltonian_path.h#L334) | Return type: `CostType ` Arguments: `uint64_t offset` Returns the memorized value at 'offset'. This is useful in the Dynamic Programming iterations. |"]]
