FillSpec

class pandas::FillSpec

pandas C++ class.

Example

#include <pandas/pandas.h>
using namespace pandas;

// Use FillSpec
FillSpec obj;
// ... operations ...

Construction

Signature	Return Type	Location	Example
static FillSpec from_legacy(double fv, const std::optional<std::string>& str_fill)	static FillSpec	pd_dataframe.h:203

Conversion

Signature	Return Type	Location	Example
static FillSpec boolean(bool v)	static FillSpec	pd_dataframe.h:197	View

Other Methods

Signature	Return Type	Location	Example
static FillSpec floating(double v){ FillSpec r	static FillSpec	pd_dataframe.h:199	View
static FillSpec integer(int64_t v){ FillSpec r	static FillSpec	pd_dataframe.h:198	View
static FillSpec nan()	static FillSpec	pd_dataframe.h:196	View
static FillSpec string(std::string v){ FillSpec r	static FillSpec	pd_dataframe.h:200	View

Code Examples

The following examples are extracted from the test suite.

boolean (pd_test_2_all.cpp:20240)

void pd_test_getitem_dispatch_classify_bool() {
    std::cout << "pd_test_getitem_dispatch_classify_bool" << std::endl;
    pandas::DataFrame df;
    std::vector<numpy::bool_> bvals = {true, false, true};
    df.insert(0, "flag", std::make_unique<pandas::Series<numpy::bool_>>(bvals, "flag"), true);

    auto t = df.classify_column_access("flag");
    check(t == pandas::DataFrame::ColumnAccessType::BoolColumn, "bool -> BoolColumn");

    // boolean (nullable) dtype
    pandas::DataFrame df2;
    auto bs = std::make_unique<pandas::Series<numpy::bool_>>(bvals, "flag2");
    bs->set_dtype_override("boolean");
    df2.insert(0, "flag2", std::move(bs), true);
    auto t2 = df2.classify_column_access("flag2");
    check(t2 == pandas::DataFrame::ColumnAccessType::BoolColumn, "boolean -> BoolColumn");
}

void pd_test_getitem_dispatch_classify_string() {
    std::cout << "pd_test_getitem_dispatch_classify_string" << std::endl;

floating (pd_test_5_all.cpp:90472)

static void f_20_847316_df_reindex_with_spec_dup(int& local_fail) {
    std::cout << "-- f_20_847316_df_reindex_with_spec_dup\n";
    expect_value_error_duplicate("c16_df_reindex_with_spec", [] {
        std::vector<pandas::Series<std::int64_t>> cols;
        cols.emplace_back(std::vector<std::int64_t>{10, 20, 30});
        cols.emplace_back(std::vector<std::int64_t>{40, 50, 60});
        pandas::DataFrame df(cols, {"c1", "c2"});
        df.set_index(std::make_unique<pandas::Index<std::string>>(
            std::vector<std::string>{"a", "a", "b"}));
        pandas::FillSpec spec = pandas::FillSpec::floating(0.0);
        auto r = df.reindex_with_spec({"a", "b", "c"}, /*axis=*/0, spec);
        (void)r;
    }, local_fail);
}

static void f_20_847317_series_unique_succeeds(int& local_fail) {
    std::cout << "-- f_20_847317_series_unique_succeeds\n";
    expect_no_exception("c17_series_unique", [&local_fail] {
        auto s = make_series<std::int64_t>({1, 2, 3}, {"a", "b", "c"});
        auto r = s.reindex({"a", "b", "c", "d"});

integer (pd_test_1_all.cpp:2897)

    void pd_test_period_array_arithmetic() {
        std::cout << "========= PeriodArray: arithmetic ======================= ";

        pandas::PeriodArray arr(std::vector<std::string>{
            "2024-01",
            "2024-06",
            "NaT"
        }, "M");

        // Add integer (shift forward)
        auto shifted = arr + 3;
        if (shifted.size() != 3) {
            std::cout << "  [FAIL] : shifted size should be 3" << std::endl;
            throw std::runtime_error("pd_test_period_array_arithmetic failed: size");
        }

        // Check ordinal shifted by 3
        auto orig0 = arr[0];
        auto shift0 = shifted[0];
        if (!orig0.has_value() || !shift0.has_value() ||

nan (pd_test_1_all.cpp:1556)

        std::cout << " -> tests passed" << std::endl;
    }

    void pd_test_floating_array_nan_conversion() {
        std::cout << "========= FloatingArray: NaN to NA conversion ======================= ";

        // NaN values should be automatically converted to NA
        pandas::FloatingArray<double> arr({
            std::optional<double>(1.0),
            std::optional<double>(std::nan("")),  // NaN
            std::optional<double>(3.0)
        });

        if (!arr.is_na(1)) {
            std::cout << "  [FAIL] : in pd_test_floating_array_nan_conversion() : NaN should be converted to NA" << std::endl;
            throw std::runtime_error("pd_test_floating_array_nan_conversion failed: NaN should be NA");
        }

        if (arr.is_na(0) || arr.is_na(2)) {
            std::cout << "  [FAIL] : in pd_test_floating_array_nan_conversion() : non-NaN should not be NA" << std::endl;

string (pd_test_1_all.cpp:941)

#include "../pandas/pd_config.h"

namespace dataframe_tests {

namespace dataframe_tests_config {

    void pd_test_config_version() {
        std::cout << "========= df_config: version info ======================= ";
        const char* version = pandas::DataFrameInfo::version();
        if (version == nullptr || std::string(version).empty()) {
            std::cout << "[FAIL] : in pd_test_config_version() : version is null or empty" << std::endl;
            throw std::runtime_error("pd_test_config_version failed: version is null or empty");
        }
        std::cout << "-> tests passed" << std::endl;
    }

    void pd_test_config_na_repr() {
        std::cout << "========= df_config: NA representation ======================= ";
        const char* na_repr = pandas::DataFrameConfig::get_na_repr();
        if (na_repr == nullptr) {