FuncArg

class pandas::FuncArg

pandas C++ class.

Example

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

// Use FuncArg
FuncArg obj;
// ... operations ...

Constructors

Signature	Location	Example
FuncArg() = default	pd_func_dispatch.h:163
FuncArg(FuncArg&&) noexcept = default	pd_func_dispatch.h:164
FuncArg(const FuncArg&) = delete	pd_func_dispatch.h:166

Construction

Signature	Return Type	Location	Example
static FuncArg from_array_like(ArrayLikeHandle h)	static FuncArg	pd_func_dispatch.h:214
static FuncArg from_callable_handle(CallableHandle h)	static FuncArg	pd_func_dispatch.h:182	View
static FuncArg from_callable_list(std::vector<FuncSpec> fns)	static FuncArg	pd_func_dispatch.h:188
static FuncArg from_dict_spec(std::map<std::string, std::vector<FuncSpec>> d)	static FuncArg	pd_func_dispatch.h:194	View
static FuncArg from_index(std::shared_ptr<IndexBase> ix)	static FuncArg	pd_func_dispatch.h:208
static FuncArg from_named_agg_list(std::vector<FuncDispatchNamedAggSpec> v)	static FuncArg	pd_func_dispatch.h:200	View
static FuncArg from_series(std::shared_ptr<Series<T>> s)	FuncArg	pd_func_dispatch.h:207
static FuncArg from_string_list(std::vector<std::string> names)	static FuncArg	pd_func_dispatch.h:176	View
static FuncArg from_string_name(std::string name)	static FuncArg	pd_func_dispatch.h:170	View

Other Methods

Signature	Return Type	Location	Example
static FuncArg none()	static FuncArg	pd_func_dispatch.h:220	View

Code Examples

The following examples are extracted from the test suite.

from_callable_handle (pd_test_5_all.cpp:53781)

                  << "  actual dtype:   [" << dts[0] << "]\n";
    }
}

static void f_series_apply_dispatch_502719_case_H1_dispatch_callable_square_int(int& local_fail) {
    std::cout << "-- case_H1_dispatch_callable_square_int\n";
    pandas::Series<std::int64_t> s({2, 3, 4}, "v");
    auto h = dispatch_test_helpers::make_stub_callable(
        dispatch_test_helpers::test_cell_int_cb([](double x) { return static_cast<std::int64_t>(x * x); }),
        "square");
    pandas::Result r = s.apply_dispatch(pandas::FuncArg::from_callable_handle(h));
    bool got = std::holds_alternative<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    pandas_tests::check(got, "case_H1.is_series_float64", local_fail);
    if (!got) return;
    auto& sp = std::get<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    bool ok = (sp->size() == 3) && (*sp)[0] == 4.0 && (*sp)[1] == 9.0 && (*sp)[2] == 16.0;
    pandas_tests::check(ok, "case_H1.values_squared", local_fail);
}

static void f_series_apply_dispatch_502719_case_H2_dispatch_callable_half_float(int& local_fail) {
    std::cout << "-- case_H2_dispatch_callable_half_float\n";

from_dict_spec (pd_test_5_all.cpp:53824)

    pandas_tests::check(ok, "case_H3.value_min_1", local_fail);
}

static void f_series_apply_dispatch_502719_case_H4_funcarg_dict_spec_kind(int& local_fail) {
    std::cout << "-- case_H4_funcarg_dict_spec_kind\n";
    std::map<std::string, std::vector<pandas::FuncSpec>> dict_specs;
    pandas::FuncSpec sum_fs;
    sum_fs.kind = pandas::FuncSpec::Kind::StringName;
    sum_fs.name = "sum";
    dict_specs["v"].push_back(std::move(sum_fs));
    auto fa = pandas::FuncArg::from_dict_spec(std::move(dict_specs));
    pandas_tests::check(fa.kind == pandas::FuncArgKind::DictSpec, "case_H4.dict_spec_kind", local_fail);
    pandas_tests::check(fa.dict_specs.size() == 1, "case_H4.dict_specs_size_1", local_fail);
    pandas_tests::check(fa.dict_specs.at("v").size() == 1, "case_H4.dict_v_size_1", local_fail);
}

static void f_series_apply_dispatch_502719_case_H5_dispatcher_unknown_throws(int& local_fail) {
    std::cout << "-- case_H5_dispatcher_unknown_throws\n";
    pandas::FuncDispatcher disp;
    pandas::FuncArg fa;
    fa.kind = pandas::FuncArgKind::Unknown;

from_named_agg_list (pd_test_5_all.cpp:110979)

    pandas_tests::check(dfp->nrows() == 2, "case_H3.nrows_2", local_fail);
}

static void f_groupby_agg_dispatch_a91f4c_case_H4_funcarg_named_agg_kind(int& local_fail) {
    std::cout << "-- case_H4_funcarg_named_agg_kind\n";
    pandas::FuncDispatchNamedAggSpec spec;
    spec.out_name = "v_total";
    spec.in_col   = "v";
    spec.fn.kind  = pandas::FuncSpec::Kind::StringName;
    spec.fn.name  = "sum";
    auto fa = pandas::FuncArg::from_named_agg_list({std::move(spec)});
    pandas_tests::check(fa.kind == pandas::FuncArgKind::NamedAggList, "case_H4.kind", local_fail);
    pandas_tests::check(fa.named_aggs.size() == 1, "case_H4.size_1", local_fail);
    pandas_tests::check(fa.named_aggs[0].out_name == "v_total", "case_H4.out_name", local_fail);
    pandas_tests::check(fa.named_aggs[0].in_col == "v", "case_H4.in_col", local_fail);
}

static void f_groupby_agg_dispatch_a91f4c_case_H5_dfgb_agg_funcarg_named(int& local_fail) {
    std::cout << "-- case_H5_dfgb_agg_funcarg_named\n";
    pandas::DataFrame df_in = make_simple_strkey_float_df();
    auto gb = df_in.groupby("k");

from_string_list (pd_test_5_all.cpp:110964)

    pandas_tests::check(got, "case_H2.is_dataframe", local_fail);
    if (!got) return;
    auto& dfp = std::get<std::unique_ptr<pandas::DataFrame>>(r.value);
    pandas_tests::check(dfp->nrows() == 2, "case_H2.nrows_2", local_fail);
}

static void f_groupby_agg_dispatch_a91f4c_case_H3_dfgb_agg_funcarg_string_list(int& local_fail) {
    std::cout << "-- case_H3_dfgb_agg_funcarg_string_list\n";
    pandas::DataFrame df_in = make_simple_strkey_float_df();
    auto gb = df_in.groupby("k");
    pandas::Result r = gb.agg(pandas::FuncArg::from_string_list({"sum", "mean"}));
    bool got = std::holds_alternative<std::unique_ptr<pandas::DataFrame>>(r.value);
    pandas_tests::check(got, "case_H3.is_dataframe", local_fail);
    if (!got) return;
    auto& dfp = std::get<std::unique_ptr<pandas::DataFrame>>(r.value);
    pandas_tests::check(dfp->nrows() == 2, "case_H3.nrows_2", local_fail);
}

static void f_groupby_agg_dispatch_a91f4c_case_H4_funcarg_named_agg_kind(int& local_fail) {
    std::cout << "-- case_H4_funcarg_named_agg_kind\n";
    pandas::FuncDispatchNamedAggSpec spec;

from_string_name (pd_test_5_all.cpp:53808)

    pandas_tests::check(got, "case_H2.is_series_float64", local_fail);
    if (!got) return;
    auto& sp = std::get<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    bool ok = (sp->size() == 3) && (*sp)[0] == 2.0 && (*sp)[1] == 4.0 && (*sp)[2] == 8.0;
    pandas_tests::check(ok, "case_H2.values_halved", local_fail);
}

static void f_series_apply_dispatch_502719_case_H3_dispatch_string_name_min(int& local_fail) {
    std::cout << "-- case_H3_dispatch_string_name_min\n";
    pandas::Series<numpy::float64> s({3.0, 1.0, 5.0}, "v");
    pandas::Result r = s.apply_dispatch(pandas::FuncArg::from_string_name("min"));
    bool got = std::holds_alternative<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    pandas_tests::check(got, "case_H3.is_series_float64", local_fail);
    if (!got) return;
    auto& sp = std::get<std::unique_ptr<pandas::Series<numpy::float64>>>(r.value);
    bool ok = (sp->size() == 1) && (*sp)[0] == 1.0;
    pandas_tests::check(ok, "case_H3.value_min_1", local_fail);
}

static void f_series_apply_dispatch_502719_case_H4_funcarg_dict_spec_kind(int& local_fail) {
    std::cout << "-- case_H4_funcarg_dict_spec_kind\n";

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});