Method matrix_data_string

source/matplot/axes_objects/matrix.cpp:129–274

    }

    std::string matrix::matrix_data_string() {
        // single matrix
        auto &matrix_ = matrices_[0];

        // calculate min/max row/cols if normalizing
        std::vector<double> value_max;
        std::vector<double> value_min;
        if (normalization_ == color_normalization::columns) {
            value_max.resize(matrix_[0].size());
            value_min.resize(matrix_[0].size());
            for (size_t i = 0; i < matrix_[0].size(); ++i) {
                value_max[i] = matrix_[0][i];
                value_min[i] = matrix_[0][i];
                for (size_t j = 0; j < matrix_.size(); ++j) {
                    if (matrix_[j][i] > value_max[i]) {
                        value_max[i] = matrix_[j][i];
                    }
                    if (matrix_[j][i] < value_min[i]) {
                        value_min[i] = matrix_[j][i];
                    }
                }
            }
        } else if (normalization_ == color_normalization::rows) {
            value_max.resize(matrix_.size());
            value_min.resize(matrix_.size());
            for (size_t i = 0; i < matrix_.size(); ++i) {
                value_max[i] = matrix_[i][0];
                value_min[i] = matrix_[i][0];
                for (size_t j = 0; j < matrix_[0].size(); ++j) {
                    if (matrix_[i][j] > value_max[i]) {
                        value_max[i] = matrix_[i][j];
                    }
                    if (matrix_[i][j] < value_min[i]) {
                        value_min[i] = matrix_[i][j];
                    }
                }
            }
        }

        // stream matrix
        std::stringstream ss;
        ss.precision(10);
        ss << std::fixed;
        double x_width_ = x_width();
        double y_width_ = y_width();
        const auto &[cb_min, cb_max] = parent_->color_box_range();
        bool use_cb_range = cb_min != cb_max;
        for (size_t i = 0; i < matrix_.size(); ++i) {
            for (size_t j = 0; j < matrix_[i].size(); ++j) {
                // z will be normalized
                double z = matrix_[i][j];
                switch (normalization_) {
                case color_normalization::none:
                    break;
                case color_normalization::columns:
                    z -= value_min[j];
                    z /= value_max[j] - value_min[j];
                    break;