> For the complete documentation index, see [llms.txt](https://openvector.gitbook.io/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://openvector.gitbook.io/docs/api-references/openapi.md). # ComputeRequest Class The `ComputeRequest` class represents a request sent to the OpenVector network to perform a computation. It encapsulates the operation to be performed, along with the operands required for the computation. ### Public Member Classes and Enums #### `enum class ComputeOperationType` Specifies the parity of the compute operation. * **Values:** * `UNARY`: Operation with one operand. * `BINARY`: Operation with two operands. * `TERNARY`: Operation with three operands. #### `enum class ComputeOperation` Specifies the type of computation to perform. * **Values:** * `DECRYPT` * `ADD` * `SUBTRACT` * `MULTIPLY` * `DIVIDE` #### `enum class DataType` Specifies the type of data being used. * **Values:** * `SINGLE`: Single data element. * `TENSOR`: Tensor data. * `TENSOR_ID`: Reference to a tensor ID (data encryption type is ignored). #### `enum class DataEncrytionType` Specifies whether the data is in plaintext or ciphertext form. * **Values:** * `PLAINTEXT` * `CIPHERTEXT` #### `class ComputeOperationOperand` Represents an operand in a compute operation. **Constructors** * **`ComputeOperationOperand(DataType data_type, DataEncrytionType encryption_type, std::string data);`** Creates an operand with the specified data type, encryption type, and data. ```cpp ComputeOperationOperand operand( ComputeRequest::DataType::SINGLE, ComputeRequest::DataEncrytionType::CIPHERTEXT, serializedData ); ``` **Member Functions** * **`DataType& data_type();`** Returns a reference to the data type. * **`const DataType& data_type() const;`** Returns a constant reference to the data type. * **`DataEncrytionType& encryption_type();`** Returns a reference to the encryption type. * **`const DataEncrytionType& encryption_type() const;`** Returns a constant reference to the encryption type. * **`std::string& data();`** Returns a reference to the data string. * **`const std::string& data() const;`** Returns a constant reference to the data string. * **`std::string to_string() const;`** Serializes the operand to a string. * **`static ComputeOperationOperand from_string(const std::string& str);`** Deserializes an operand from a string. * **`static std::vector from_string(const std::string& str, size_t num_operands);`** Deserializes multiple operands from a string. #### `class ComputeOperationInstance` Represents an instance of a compute operation, including its type and operands. **Constructors** * **`ComputeOperationInstance(const ComputeOperationType& operation_type, const ComputeOperation& operation, const std::vector& operands);`** Creates a compute operation instance. ```cpp ComputeOperationInstance operation( ComputeOperationType::BINARY, ComputeOperation::ADD, { operand1, operand2 } ); ``` **Member Functions** * **`ComputeOperationType& operation_type();`** Returns a reference to the operation type. * **`const ComputeOperationType& operation_type() const;`** Returns a constant reference to the operation type. * **`ComputeOperation& operation();`** Returns a reference to the operation. * **`const ComputeOperation& operation() const;`** Returns a constant reference to the operation. * **`std::vector& operands();`** Returns a reference to the vector of operands. * **`const std::vector& operands() const;`** Returns a constant reference to the vector of operands. * **`std::string to_string() const;`** Serializes the operation instance to a string. * **`static ComputeOperationInstance from_string(const std::string& str);`** Deserializes an operation instance from a string. ### Constructors #### `ComputeRequest(const ComputeOperationInstance& operation);` Creates a compute request with the specified operation instance. ```cpp ComputeRequest request(operationInstance); ``` ### Member Functions * **`ComputeOperationInstance& operation();`** Returns a reference to the compute operation instance. * **`const ComputeOperationInstance& operation() const;`** Returns a constant reference to the compute operation instance. * **`std::string to_string() const;`** Serializes the compute request to a string. * **`static ComputeRequest from_string(const std::string& str);`** Deserializes a compute request from a string. ### Usage Example ```cpp // Assuming cs is an instance of CryptoSystem and pk is the network public key // Encrypt two plaintexts PlainTextImpl pt1 = cs.make_plaintext(5.0f); PlainTextImpl pt2 = cs.make_plaintext(7.0f); CipherTextImpl ct1 = cs.encrypt(pk, pt1); CipherTextImpl ct2 = cs.encrypt(pk, pt2); // Serialize the ciphertexts std::string serialized_ct1 = cs.serialize_ciphertext(ct1); std::string serialized_ct2 = cs.serialize_ciphertext(ct2); // Create operands ComputeRequest::ComputeOperationOperand operand1( ComputeRequest::DataType::SINGLE, ComputeRequest::DataEncrytionType::CIPHERTEXT, serialized_ct1 ); ComputeRequest::ComputeOperationOperand operand2( ComputeRequest::DataType::SINGLE, ComputeRequest::DataEncrytionType::CIPHERTEXT, serialized_ct2 ); // Create compute operation instance for addition ComputeRequest::ComputeOperationInstance operation( ComputeRequest::ComputeOperationType::BINARY, ComputeRequest::ComputeOperation::ADD, { operand1, operand2 } ); // Create the compute request ComputeRequest request(operation); // Send the request using ClientNode ComputeResponse* response = nullptr; clientNode.compute(request, &response); ``` ### Notes * When creating a `ComputeRequest`, ensure that the data in operands is correctly serialized and corresponds to the expected encryption and data types. * The `ComputeOperation` enum defines basic arithmetic operations and decryption. More operations can be added as needed. ### See Also * [ClientNode Class](/docs/api-references/markdown.md) * [ComputeResponse Class](/docs/api-references/computeresponse-class.md) * [CryptoSystem Interface](/docs/api-references/editor.md)