FixedPoint.h

Go to the documentation of this file.

/*
 *  SPDX-FileCopyrightText: 2026 Faris Serdar Taşel <fst@cankaya.edu.tr>
 *  SPDX-FileCopyrightText: 2026 Efe Çiftci <efeciftci@cankaya.edu.tr>
 *
 *  SPDX-License-Identifier: MIT
 */
 
#pragma once
#include <openfhe/binfhe/binfhecontext.h>
#include <vector>
 
using namespace lbcrypto;
using namespace std;
 
#define COPY_CT(x) std::make_shared<LWECiphertextImpl>(*x)
 
namespace computefhe {
 
    struct BinaryDigit : public Serializable {
        static uint
            new_id;      
        uint id = 0;     
        LWECiphertext c; 
        LWEPlaintext p;  
        bool is_ct; 
 
        BinaryDigit();
        BinaryDigit(const BinaryDigit &other);
        BinaryDigit(ConstLWECiphertext &ct);
        BinaryDigit(const LWECiphertext &ct);
        BinaryDigit(LWEPlaintext pt);
        BinaryDigit(const ConstLWECiphertext &ct, LWEPlaintext pt,
                    bool is_ct = false);
 
        BinaryDigit &operator=(const BinaryDigit &other);
        BinaryDigit &operator=(const LWECiphertext &other);
        BinaryDigit &operator=(LWEPlaintext pt);
 
        bool operator==(const BinaryDigit &other) const;
        bool operator!=(const BinaryDigit &other) const;
 
        operator LWECiphertext &();
        operator const LWECiphertext &() const;
        operator ConstLWECiphertext() const;
        operator LWEPlaintext() const;
 
        // Serialization support
        template <class Archive>
        void save(Archive &ar, std::uint32_t const version) const {
            ar(cereal::make_nvp("c", c));
            ar(cereal::make_nvp("p", p));
            ar(cereal::make_nvp("is_ct", is_ct));
        }
 
        template <class Archive>
        void load(Archive &ar, std::uint32_t const version) {
            if (version > SerializedVersion()) {
                OPENFHE_THROW("serialized object version " +
                              std::to_string(version) +
                              " is from a later version of the library");
            }
            ar(cereal::make_nvp("c", c));
            ar(cereal::make_nvp("p", p));
            ar(cereal::make_nvp("is_ct", is_ct));
            this->id = new_id++;
        }
 
        std::string SerializedObjectName() const override {
            return "BinaryDigit";
        }
 
        static uint32_t SerializedVersion() { return 1; }
    };
 
    struct FixedPoint : public vector<BinaryDigit> {
        FixedPoint();
        FixedPoint(size_t n);
        FixedPoint(vector<BinaryDigit>::const_iterator begin,
                   vector<BinaryDigit>::const_iterator end);
        FixedPoint(std::initializer_list<BinaryDigit> list);
        FixedPoint(const vector<BinaryDigit> &other);
        FixedPoint(const vector<LWECiphertext> &other);
        FixedPoint(const vector<LWEPlaintext> &other);
 
        bool is_ct() const;
    };
} // namespace computefhe