Function MakeQuantizedColumnWithDefaultBin

catboost/libs/data/quantization.cpp:876–934

        class TDst,
        class TSrc>
    static void MakeQuantizedColumnWithDefaultBin(
        const TSrc& srcFeature,
        TValueQuantizer<TSrc> valueQuantizer,
        ESparseArrayIndexingType sparseArrayIndexingType,

        // pass as parameter to enable type deduction
        THolder<TDst>* dstFeature
    ) {
        using TDenseSrcData = TPolymorphicArrayValuesHolder<TSrc>;
        using TSparseSrcData = TSparsePolymorphicArrayValuesHolder<TSrc>;

        Y_ASSERT(valueQuantizer.GetDstBitsPerKey() == sizeof(TStoredDstValue) * CHAR_BIT);

        ui32 defaultQuantizedBin = *valueQuantizer.GetDefaultBin();

        TSparseArrayIndexingBuilderPtr<ui32> indexingBuilder
            = CreateSparseArrayIndexingBuilder<ui32>(sparseArrayIndexingType);

        constexpr size_t ALLOC_BLOCK = 8192;

        TVector<ui64> quantizedDataStorage;

        ui32 nonDefaultValuesCount = 0;

        auto onSrcNonDefaultValueCallback = [&, valueQuantizer, defaultQuantizedBin] (ui32 idx, typename TSrc::TValueType value) {
            auto quantizedBin = valueQuantizer.Quantize(value);
            if (quantizedBin != defaultQuantizedBin) {
                indexingBuilder->AddOrdered(idx);

                if (nonDefaultValuesCount % (ALLOC_BLOCK * sizeof(ui64) / sizeof(TStoredDstValue)) == 0) {
                    quantizedDataStorage.yresize(nonDefaultValuesCount + ALLOC_BLOCK);
                }
                ((TStoredDstValue*)quantizedDataStorage.data())[nonDefaultValuesCount] = quantizedBin;
                ++nonDefaultValuesCount;
            }
        };

        if (const auto* denseSrcFeature = dynamic_cast<const TDenseSrcData*>(&srcFeature)){
            denseSrcFeature->GetData()->ForEach(onSrcNonDefaultValueCallback);
        } else if (const auto* sparseSrcFeature = dynamic_cast<const TSparseSrcData*>(&srcFeature)) {
            const auto& sparseArray = sparseSrcFeature->GetData();
            sparseArray.ForEachNonDefault(onSrcNonDefaultValueCallback);
        } else {
            CB_ENSURE_INTERNAL(false, "MakeQuantizedColumnWithDefaultBin: unsupported src feature type");
        }

        *dstFeature = MakeHolder<TSparseCompressedValuesHolderImpl<TDst>>(
            srcFeature.GetId(),
            TSparseCompressedArray<typename TDst::TValueType, ui32>(
                indexingBuilder->Build(srcFeature.GetSize()),
                TCompressedArray(
                    nonDefaultValuesCount,
                    valueQuantizer.GetDstBitsPerKey(),
                    std::move(quantizedDataStorage)
                ),
                std::move(defaultQuantizedBin)
            )
        );