NamedAgg

class pandas::NamedAgg

pandas C++ class.

Example

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

// Use NamedAgg
NamedAgg obj;
// ... operations ...

Constructors

Signature	Location	Example
NamedAgg(const std::string& col, const std::string& func)	pd_grouper.h:119

Indexing / Selection

Signature	Return Type	Location	Example
static NamedAgg first(const std::string& col)	static NamedAgg	pd_grouper.h:151	View
static NamedAgg last(const std::string& col)	static NamedAgg	pd_grouper.h:155	View

Statistics

Signature	Return Type	Location	Example
static NamedAgg count(const std::string& col)	static NamedAgg	pd_grouper.h:131	View
static NamedAgg max(const std::string& col)	static NamedAgg	pd_grouper.h:139	View
static NamedAgg mean(const std::string& col)	static NamedAgg	pd_grouper.h:127	View
static NamedAgg median(const std::string& col)	static NamedAgg	pd_grouper.h:159	View
static NamedAgg min(const std::string& col)	static NamedAgg	pd_grouper.h:135	View
static NamedAgg std(const std::string& col)	static NamedAgg	pd_grouper.h:143	View
static NamedAgg sum(const std::string& col)	static NamedAgg	pd_grouper.h:123	View
static NamedAgg var(const std::string& col)	static NamedAgg	pd_grouper.h:147	View

Other Methods

Signature	Return Type	Location	Example
static NamedAgg size(const std::string& col)	static NamedAgg	pd_grouper.h:163	View

Code Examples

The following examples are extracted from the test suite.

first (pd_test_1_all.cpp:11616)

        void pd_test_groupby_first_last() {
            std::cout << "========= GroupBy first/last ====================";

            std::map<std::string, std::vector<double>> data = {
                {"category", {1.0, 1.0, 2.0, 2.0}},
                {"value", {10.0, 20.0, 30.0, 40.0}}
            };
            pandas::DataFrame df(data);

            auto first_result = df.groupby("category").first();
            auto last_result = df.groupby("category").last();

            // First for group 1: 10, group 2: 30
            // Last for group 1: 20, group 2: 40
            double first1 = std::stod(first_result["value"].get_value_str(0));
            double first2 = std::stod(first_result["value"].get_value_str(1));

            bool passed = ((std::abs(first1 - 10.0) < 0.001 && std::abs(first2 - 30.0) < 0.001) ||
                          (std::abs(first1 - 30.0) < 0.001 && std::abs(first2 - 10.0) < 0.001));
            if (!passed) {

last (pd_test_1_all.cpp:11617)

        void pd_test_groupby_first_last() {
            std::cout << "========= GroupBy first/last ====================";

            std::map<std::string, std::vector<double>> data = {
                {"category", {1.0, 1.0, 2.0, 2.0}},
                {"value", {10.0, 20.0, 30.0, 40.0}}
            };
            pandas::DataFrame df(data);

            auto first_result = df.groupby("category").first();
            auto last_result = df.groupby("category").last();

            // First for group 1: 10, group 2: 30
            // Last for group 1: 20, group 2: 40
            double first1 = std::stod(first_result["value"].get_value_str(0));
            double first2 = std::stod(first_result["value"].get_value_str(1));

            bool passed = ((std::abs(first1 - 10.0) < 0.001 && std::abs(first2 - 30.0) < 0.001) ||
                          (std::abs(first1 - 30.0) < 0.001 && std::abs(first2 - 10.0) < 0.001));
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_groupby_first_last() : first values incorrect" << std::endl;

count (pd_test_1_all.cpp:66)

        if (arr.is_na(0)) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : is_na(0) should be false" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: is_na(0) should be false");
        }

        if (!arr.has_na()) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : has_na() should be true" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: has_na() should be true");
        }

        if (arr.count() != 2) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_na_handling() : count() should be 2" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_na_handling failed: count() should be 2");
        }

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

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

max (pd_test_1_all.cpp:771)

        pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered

        // Test min
        std::optional<std::string> min_val = arr.min();
        if (!min_val.has_value() || *min_val != "low") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
        }

        // Test max
        std::optional<std::string> max_val = arr.max();
        if (!max_val.has_value() || *max_val != "high") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");
        }

        // Test unordered throws for min/max
        pandas::CategoricalArray unordered = arr.as_unordered();
        bool threw = false;
        try {
            unordered.min();

mean (pd_test_1_all.cpp:282)

            std::optional<bool>(true),
            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

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

    void pd_test_boolean_array_dtype() {
        std::cout << "========= BooleanArray: dtype ======================= ";

median (pd_test_1_all.cpp:20910)

                throw std::runtime_error("pd_test_expanding_var failed: expanding var values incorrect");
            }

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

        void pd_test_expanding_median() {
            std::cout << "========= Expanding median ======================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
            auto result = s.expanding().median();

            // Expanding median: 1, 1.5, 2, 2.5, 3
            bool passed = std::abs(result[0] - 1.0) < 0.001 &&
                          std::abs(result[1] - 1.5) < 0.001 &&
                          std::abs(result[2] - 2.0) < 0.001 &&
                          std::abs(result[3] - 2.5) < 0.001 &&
                          std::abs(result[4] - 3.0) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_expanding_median() : expanding median values incorrect" << std::endl;
                throw std::runtime_error("pd_test_expanding_median failed: expanding median values incorrect");

min (pd_test_1_all.cpp:764)

    }

    void pd_test_categorical_array_ordered_operations() {
        std::cout << "========= CategoricalArray: ordered operations (min/max) ======================= ";

        std::vector<std::string> cats = {"low", "medium", "high"};
        std::vector<numpy::int32> codes = {0, 2, 1, 0, -1};  // low, high, medium, low, NA
        pandas::CategoricalArray arr = pandas::CategoricalArray::from_codes(codes, cats, true);  // ordered

        // Test min
        std::optional<std::string> min_val = arr.min();
        if (!min_val.has_value() || *min_val != "low") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : min != 'low'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: min != 'low'");
        }

        // Test max
        std::optional<std::string> max_val = arr.max();
        if (!max_val.has_value() || *max_val != "high") {
            std::cout << "  [FAIL] : in pd_test_categorical_array_ordered_operations() : max != 'high'" << std::endl;
            throw std::runtime_error("pd_test_categorical_array_ordered_operations failed: max != 'high'");

std (pd_test_1_all.cpp:4526)

#include "../pandas/pd_series.h"

namespace dataframe_tests {
    namespace dataframe_tests_aggregation {

        void pd_test_aggregation_series_sem() {
            std::cout << "========= Series sem ============================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
            auto sem_val = s.sem();
            // std(ddof=1) = sqrt(2.5), sem = sqrt(2.5)/sqrt(5) ≈ 0.707
            bool passed = sem_val.has_value() && std::abs(*sem_val - 0.707) < 0.01;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_aggregation_series_sem() : sem value incorrect" << std::endl;
                throw std::runtime_error("pd_test_aggregation_series_sem failed: sem value incorrect");
            }

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

        void pd_test_aggregation_series_quantile() {

sum (pd_test_1_all.cpp:276)

        }

        // Test sum/mean
        pandas::BooleanArray arr({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::optional<bool>(true),
            std::optional<bool>(true)
        });

        auto s = arr.sum();
        if (!s.has_value() || s.value() != 3) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : sum should be 3" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: sum");
        }

        auto m = arr.mean();
        if (!m.has_value() || std::abs(m.value() - 0.75) > 0.001) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_reductions() : mean should be 0.75" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_reductions failed: mean");
        }

var (pd_test_1_all.cpp:20890)

                throw std::runtime_error("pd_test_expanding_std failed: expanding std values incorrect");
            }

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

        void pd_test_expanding_var() {
            std::cout << "========= Expanding var =========================";

            pandas::Series<double> s({1.0, 2.0, 3.0, 4.0, 5.0});
            auto result = s.expanding().var();

            // Expanding var (ddof=1): NaN, 0.5, 1.0, 1.6667, 2.5
            bool passed = std::isnan(result[0]) &&
                          std::abs(result[1] - 0.5) < 0.001 &&
                          std::abs(result[2] - 1.0) < 0.001 &&
                          std::abs(result[3] - 1.6667) < 0.001 &&
                          std::abs(result[4] - 2.5) < 0.001;
            if (!passed) {
                std::cout << "  [FAIL] : in pd_test_expanding_var() : expanding var values incorrect" << std::endl;
                throw std::runtime_error("pd_test_expanding_var failed: expanding var values incorrect");

size (pd_test_1_all.cpp:22)

#include "../pandas/pd_boolean_array.h"

namespace dataframe_tests {

namespace dataframe_tests_boolean_array {
    void pd_test_boolean_array_constructors() {
        std::cout << "========= BooleanArray: constructors ======================= ";

        // Default constructor
        pandas::BooleanArray arr1;
        if (arr1.size() != 0) {
            std::cout << "  [FAIL] : in pd_test_boolean_array_constructors() : default constructor size != 0" << std::endl;
            throw std::runtime_error("pd_test_boolean_array_constructors failed: default constructor size != 0");
        }

        // Initializer list constructor
        pandas::BooleanArray arr2({
            std::optional<bool>(true),
            std::optional<bool>(false),
            std::nullopt,
            std::optional<bool>(true)