GenericScalar

class pandas::GenericScalar

pandas C++ class.

Example

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

// Use GenericScalar
GenericScalar obj;
// ... operations ...

Construction

Signature	Return Type	Location	Example
static GenericScalar from_bool(bool v)	static GenericScalar	pd_generic_array_formatter.h:63
static GenericScalar from_string(std::string s)	static GenericScalar	pd_generic_array_formatter.h:66	View

Other Methods

Signature	Return Type	Location	Example
static GenericScalar na()	static GenericScalar	pd_generic_array_formatter.h:60	View
static GenericScalar nan()	static GenericScalar	pd_generic_array_formatter.h:62	View
static GenericScalar nat()	static GenericScalar	pd_generic_array_formatter.h:61	View
static GenericScalar none()	static GenericScalar	pd_generic_array_formatter.h:59	View

Code Examples

The following examples are extracted from the test suite.

from_string (pd_test_3_all.cpp:10837)

    const auto& s1 = df.column<int64_t>("A");
    const auto& s2 = df.col<int64_t>("A");
    if (s1.size() != s2.size() || s1[0] != s2[0]) {
        std::cout << "  [FAIL] : in pd_test_3_all_column_alias() : mismatch" << std::endl;
        throw std::runtime_error("pd_test_3_all_column_alias failed");
    }
    std::cout << " -> tests passed" << std::endl;
}

void pd_test_3_all_timedelta_from_string() {
    std::cout << "========= Timedelta::from_string() ======================";
    auto td1 = pandas::Timedelta::from_string("1 days");
    pandas::Timedelta td2("1 days");
    if (td1.value() != td2.value()) {
        std::cout << "  [FAIL] : in pd_test_3_all_timedelta_from_string() : mismatch" << std::endl;
        throw std::runtime_error("pd_test_3_all_timedelta_from_string failed");
    }
    std::cout << " -> tests passed" << std::endl;
}

void pd_test_3_all_replace_int() {

na (pd_test_1_all.cpp:84)

    void pd_test_boolean_array_kleene_and() {
        std::cout << "========= BooleanArray: Kleene AND ======================= ";

        // Kleene AND truth table:
        // T & T = T, T & F = F, T & NA = NA
        // F & T = F, F & F = F, F & NA = F (False dominates)
        // NA & T = NA, NA & F = F, NA & NA = NA

        pandas::BooleanArray t({std::optional<bool>(true)});
        pandas::BooleanArray f({std::optional<bool>(false)});
        pandas::BooleanArray na({std::nullopt});

        // T & T = T
        auto tt = (t & t);
        if (!tt[0].has_value() || !tt[0].value()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_kleene_and() : T & T should be T" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_kleene_and failed: T & T");
        }

        // T & F = F
        auto tf = (t & f);

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;

nat (pd_test_5_all.cpp:97717)

    std::string result_override;
    std::string variant_label;
};

static pandas::FillValue fv_none()         { return pandas::FillValue::none(); }

static pandas::FillValue fv_nan()          { return pandas::FillValue::nan(); }

static pandas::FillValue fv_na()           { return pandas::FillValue::na(); }

static pandas::FillValue fv_nat()          { return pandas::FillValue::nat(); }

static pandas::FillValue fv_bool_false()   { return pandas::FillValue::of_bool(false); }

static pandas::FillValue fv_num_zero()     { return pandas::FillValue::of_numeric(0.0); }

static pandas::FillValue fv_string_x()     { return pandas::FillValue::of_string("x"); }

static Probe probe_result(pandas::Result& r) {
    Probe p;
    std::visit([&](auto& alt) {

none (pd_test_5_all.cpp:90413)

                                    pandas::FillValue::of_bool(true));
        (void)r;
    }, local_fail);
}

static void f_20_847312_dispatch_complex_none(int& local_fail) {
    std::cout << "-- f_20_847312_dispatch_complex_none\n";
    expect_value_error_duplicate("c12_dispatch_complex_none", [] {
        auto s = make_series<cplx>({{1, 2}, {3, 4}, {5, 6}}, {"c1", "c1", "c2"});
        auto r = s.reindex_dispatch({"c1", "c2", "c3"}, "",
                                    pandas::FillValue::none());
        (void)r;
    }, local_fail);
}

static void f_20_847313_df_dup_rows_axis0(int& local_fail) {
    std::cout << "-- f_20_847313_df_dup_rows_axis0\n";
    expect_value_error_duplicate("c13_df_dup_rows_axis0", [] {
        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});