#include "InferenceTestImage.hpp"
#include "CaffePreprocessor.hpp"
-#include <boost/numeric/conversion/cast.hpp>
+#include <armnn/utility/NumericCast.hpp>
+
#include <boost/format.hpp>
#include <iostream>
std::unique_ptr<CaffePreprocessor::TTestCaseData> CaffePreprocessor::GetTestCaseData(unsigned int testCaseId)
{
- testCaseId = testCaseId % boost::numeric_cast<unsigned int>(m_ImageSet.size());
+ testCaseId = testCaseId % armnn::numeric_cast<unsigned int>(m_ImageSet.size());
const ImageSet& imageSet = m_ImageSet[testCaseId];
const std::string fullPath = m_BinaryDirectory + imageSet.first;
#include "Cifar10Database.hpp"
#include <armnn/Logging.hpp>
+#include <armnn/utility/NumericCast.hpp>
-#include <boost/numeric/conversion/cast.hpp>
#include <fstream>
#include <vector>
{
for (unsigned int w = 0; w < 32; w++)
{
- inputImageData[countR_o] = boost::numeric_cast<float>(I[countR++]);
- inputImageData[countG_o] = boost::numeric_cast<float>(I[countG++]);
- inputImageData[countB_o] = boost::numeric_cast<float>(I[countB++]);
+ // Static_cast of unsigned char is safe with float
+ inputImageData[countR_o] = static_cast<float>(I[countR++]);
+ inputImageData[countG_o] = static_cast<float>(I[countG++]);
+ inputImageData[countB_o] = static_cast<float>(I[countB++]);
countR_o += step;
countG_o += step;
}
}
- const unsigned int label = boost::numeric_cast<unsigned int>(I[0]);
+ const unsigned int label = armnn::numeric_cast<unsigned int>(I[0]);
return std::make_unique<TTestCaseData>(label, std::move(inputImageData));
}
#include <vector>
#include <armnn/TypesUtils.hpp>
-
-#include <boost/numeric/conversion/cast.hpp>
+#include <armnn/utility/NumericCast.hpp>
#include <array>
#include <string>
return ParseArrayImpl<uint8_t>(stream,
[&quantizationScale, &quantizationOffset](const std::string & s)
{
- return boost::numeric_cast<uint8_t>(
+ return armnn::numeric_cast<uint8_t>(
armnn::Quantize<uint8_t>(std::stof(s),
quantizationScale,
quantizationOffset));
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
-#include <boost/numeric/conversion/cast.hpp>
#include <boost/test/tools/floating_point_comparison.hpp>
#include <vector>
#include <armnn/TypesUtils.hpp>
#include <armnnUtils/Permute.hpp>
+#include <armnn/utility/NumericCast.hpp>
-#include <boost/numeric/conversion/cast.hpp>
#include <boost/format.hpp>
#include <iostream>
unsigned int ImagePreprocessor<TDataType>::GetLabelAndResizedImageAsFloat(unsigned int testCaseId,
std::vector<float> & result)
{
- testCaseId = testCaseId % boost::numeric_cast<unsigned int>(m_ImageSet.size());
+ testCaseId = testCaseId % armnn::numeric_cast<unsigned int>(m_ImageSet.size());
const ImageSet& imageSet = m_ImageSet[testCaseId];
const std::string fullPath = m_BinaryDirectory + imageSet.first;
// duplicate data across the batch
for (unsigned int i = 1; i < m_BatchSize; i++)
{
- result.insert(result.end(), result.begin(), result.begin() + boost::numeric_cast<int>(GetNumImageElements()));
+ result.insert(result.end(), result.begin(), result.begin() + armnn::numeric_cast<int>(GetNumImageElements()));
}
if (m_DataFormat == DataFormat::NCHW)
#include <armnn/utility/Timer.hpp>
#include <armnn/BackendRegistry.hpp>
#include <armnn/utility/Assert.hpp>
+#include <armnn/utility/NumericCast.hpp>
#if defined(ARMNN_SERIALIZER)
#include "armnnDeserializer/IDeserializer.hpp"
network = parser->CreateNetworkFromBinary(file);
}
- unsigned int subgraphId = boost::numeric_cast<unsigned int>(params.m_SubgraphId);
+ unsigned int subgraphId = armnn::numeric_cast<unsigned int>(params.m_SubgraphId);
for (const std::string& inputLayerName : params.m_InputBindings)
{
boost::apply_visitor([expectedOutputDataSize, i](auto&& value)
{
- const unsigned int actualOutputDataSize = boost::numeric_cast<unsigned int>(value.size());
+ const unsigned int actualOutputDataSize = armnn::numeric_cast<unsigned int>(value.size());
if (actualOutputDataSize < expectedOutputDataSize)
{
- unsigned int outputIndex = boost::numeric_cast<unsigned int>(i);
+ unsigned int outputIndex = i;
throw armnn::Exception(
fmt::format("Not enough data for output #{0}: expected "
"{1} elements, got {2}", outputIndex, expectedOutputDataSize, actualOutputDataSize));
#include "InferenceTest.hpp"
#include <armnn/utility/Assert.hpp>
+#include <armnn/utility/NumericCast.hpp>
+
#include <boost/numeric/conversion/cast.hpp>
#include <boost/program_options.hpp>
#include <fmt/format.h>
unsigned int prediction = 0;
boost::apply_visitor([&](auto&& value)
{
- prediction = boost::numeric_cast<unsigned int>(
+ prediction = armnn::numeric_cast<unsigned int>(
std::distance(value.begin(), std::max_element(value.begin(), value.end())));
},
output);
#include <armnn/utility/Assert.hpp>
#include <armnn/utility/IgnoreUnused.hpp>
+#include <armnn/utility/NumericCast.hpp>
#include <boost/numeric/conversion/cast.hpp>
#include <fmt/format.h>
throw InferenceTestImageLoadFailed(fmt::format("Could not load empty image at {}", filePath));
}
- m_Width = boost::numeric_cast<unsigned int>(width);
- m_Height = boost::numeric_cast<unsigned int>(height);
- m_NumChannels = boost::numeric_cast<unsigned int>(channels);
+ m_Width = armnn::numeric_cast<unsigned int>(width);
+ m_Height = armnn::numeric_cast<unsigned int>(height);
+ m_NumChannels = armnn::numeric_cast<unsigned int>(channels);
const unsigned int sizeInBytes = GetSizeInBytes();
m_Data.resize(sizeInBytes);
std::vector<uint8_t> newData;
newData.resize(newWidth * newHeight * im.GetNumChannels() * im.GetSingleElementSizeInBytes());
- // boost::numeric_cast<>() is used for user-provided data (protecting about overflows).
+ // armnn::numeric_cast<>() is used for user-provided data (protecting about overflows).
// static_cast<> is ok for internal data (assumes that, when internal data was originally provided by a user,
- // a boost::numeric_cast<>() handled the conversion).
- const int nW = boost::numeric_cast<int>(newWidth);
- const int nH = boost::numeric_cast<int>(newHeight);
+ // a armnn::numeric_cast<>() handled the conversion).
+ const int nW = armnn::numeric_cast<int>(newWidth);
+ const int nH = armnn::numeric_cast<int>(newHeight);
const int w = static_cast<int>(im.GetWidth());
const int h = static_cast<int>(im.GetHeight());
#include <armnn/Logging.hpp>
-#include <boost/numeric/conversion/cast.hpp>
-
#include <fstream>
#include <vector>
for (unsigned int i = 0; i < col * row; ++i)
{
- inputImageData[i] = boost::numeric_cast<float>(I[i]);
+ // Static_cast of unsigned char is safe with float
+ inputImageData[i] = static_cast<float>(I[i]);
if(m_ScaleValues)
{
#include <QuantizeHelper.hpp>
#include <armnn/TypesUtils.hpp>
-
-#include <boost/numeric/conversion/cast.hpp>
+#include <armnn/utility/NumericCast.hpp>
#include <array>
#include <memory>
std::unique_ptr<MobileNetSsdTestCaseData> MobileNetSsdDatabase::GetTestCaseData(unsigned int testCaseId)
{
const unsigned int safeTestCaseId =
- testCaseId % boost::numeric_cast<unsigned int>(g_PerTestCaseInput.size());
+ testCaseId % armnn::numeric_cast<unsigned int>(g_PerTestCaseInput.size());
const ObjectDetectionInput& testCaseInput = g_PerTestCaseInput[safeTestCaseId];
// Load test case input
//
#include <armnn/ArmNN.hpp>
#include <armnn/TypesUtils.hpp>
+#include <armnn/utility/NumericCast.hpp>
#include <armnn/utility/Timer.hpp>
#if defined(ARMNN_SERIALIZER)
auto ParseDataArray<armnn::DataType::QAsymmU8>(std::istream& stream)
{
return ParseArrayImpl<uint8_t>(stream,
- [](const std::string& s) { return boost::numeric_cast<uint8_t>(std::stoi(s)); });
+ [](const std::string& s) { return armnn::numeric_cast<uint8_t>(std::stoi(s)); });
}
template<>
return ParseArrayImpl<uint8_t>(stream,
[&quantizationScale, &quantizationOffset](const std::string & s)
{
- return boost::numeric_cast<uint8_t>(
+ return armnn::numeric_cast<uint8_t>(
armnn::Quantize<uint8_t>(std::stof(s),
quantizationScale,
quantizationOffset));
std::vector<unsigned int> ParseArray(std::istream& stream)
{
return ParseArrayImpl<unsigned int>(stream,
- [](const std::string& s) { return boost::numeric_cast<unsigned int>(std::stoi(s)); });
+ [](const std::string& s) { return armnn::numeric_cast<unsigned int>(std::stoi(s)); });
}
std::vector<std::string> ParseStringList(const std::string & inputString, const char * delimiter)
#include <armnn/Exceptions.hpp>
#include <armnn/Logging.hpp>
+#include <armnn/utility/NumericCast.hpp>
+
#include <array>
#include <cstdint>
#include <tuple>
#include <utility>
#include <boost/format.hpp>
-#include <boost/numeric/conversion/cast.hpp>
#include "InferenceTestImage.hpp"
std::unique_ptr<YoloDatabase::TTestCaseData> YoloDatabase::GetTestCaseData(unsigned int testCaseId)
{
- testCaseId = testCaseId % boost::numeric_cast<unsigned int>(g_PerTestCaseInputOutput.size());
+ testCaseId = testCaseId % armnn::numeric_cast<unsigned int>(g_PerTestCaseInputOutput.size());
const auto& testCaseInputOutput = g_PerTestCaseInputOutput[testCaseId];
const std::string imagePath = m_ImageDir + testCaseInputOutput.first;
#include <ProfilingService.hpp>
#include <TimelinePacketWriterFactory.hpp>
+#include <armnn/utility/NumericCast.hpp>
+
#include <server/include/timelineDecoder/TimelineDirectoryCaptureCommandHandler.hpp>
#include <server/include/timelineDecoder/TimelineDecoder.hpp>
#include <MockBackend.hpp>
-#include <boost/cast.hpp>
#include <boost/test/test_tools.hpp>
#include <boost/test/unit_test_suite.hpp>
-
BOOST_AUTO_TEST_SUITE(GatordMockTests)
using namespace armnn;
BOOST_AUTO_TEST_CASE(CounterCaptureHandlingTest)
{
- using boost::numeric_cast;
-
arm::pipe::PacketVersionResolver packetVersionResolver;
// Data with timestamp, counter idx & counter values
std::unique_ptr<unsigned char[]> uniqueData2 = std::make_unique<unsigned char[]>(dataLength);
unsigned char* data2 = reinterpret_cast<unsigned char*>(uniqueData2.get());
- uint32_t sizeOfUint64 = numeric_cast<uint32_t>(sizeof(uint64_t));
- uint32_t sizeOfUint32 = numeric_cast<uint32_t>(sizeof(uint32_t));
- uint32_t sizeOfUint16 = numeric_cast<uint32_t>(sizeof(uint16_t));
+ uint32_t sizeOfUint64 = armnn::numeric_cast<uint32_t>(sizeof(uint64_t));
+ uint32_t sizeOfUint32 = armnn::numeric_cast<uint32_t>(sizeof(uint32_t));
+ uint32_t sizeOfUint16 = armnn::numeric_cast<uint32_t>(sizeof(uint16_t));
// Offset index to point to mem address
uint32_t offset = 0;