Shuenhoy/vtk-m2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Deal with small integer promotions

Browse Source 
C and C++ has a funny feature where operations on small integers (char
and short) actually promote the result to a 32 bit integer. Most often
in our code the result is pushed back to the same type, and picky compilers
can then give a warning about an implicit type conversion (that we
inevitably don't care about). Here are a lot of changes to suppress
the warnings.
This commit is contained in:
Kenneth Moreland 2015-07-30 16:43:19 -06:00
parent 21b3b318ba
commit 04fce28ae3
11 changed files with 61 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
vtkm/Matrix.h
View File

@ -161,13 +161,13 @@ vtkm::Matrix<T,NumRow,NumCol> MatrixMultiply(
{
for (vtkm::IdComponent colIndex = 0; colIndex < NumCol; colIndex++)
{
T sum = leftFactor(rowIndex, 0) * rightFactor(0, colIndex);
T sum = T(leftFactor(rowIndex, 0) * rightFactor(0, colIndex));
for (vtkm::IdComponent internalIndex = 1;
internalIndex < NumInternal;
internalIndex++)
{
sum += leftFactor(rowIndex, internalIndex)
* rightFactor(internalIndex, colIndex);
sum = T(sum + (leftFactor(rowIndex, internalIndex)
* rightFactor(internalIndex, colIndex)));
}
result(rowIndex, colIndex) = sum;
}

20
vtkm/Types.h
View File

@ -677,7 +677,7 @@ struct Add
template<typename T>
VTKM_EXEC_CONT_EXPORT T operator()(const T &a, const T &b) const
{
return a + b;
return T(a + b);
}
};
@ -686,7 +686,7 @@ struct Subtract
template<typename T>
VTKM_EXEC_CONT_EXPORT T operator()(const T &a, const T &b) const
{
return a - b;
return T(a - b);
}
};
@ -695,7 +695,7 @@ struct Multiply
template<typename T>
VTKM_EXEC_CONT_EXPORT T operator()(const T &a, const T &b) const
{
return a * b;
return T(a * b);
}
};
@ -704,7 +704,7 @@ struct Divide
template<typename T>
VTKM_EXEC_CONT_EXPORT T operator()(const T &a, const T &b) const
{
return a / b;
return T(a / b);
}
};
@ -713,7 +713,7 @@ struct Negate
template<typename T>
VTKM_EXEC_CONT_EXPORT T operator()(const T &x) const
{
return -x;
return T(-x);
}
};
@ -1055,10 +1055,10 @@ template<typename T, vtkm::IdComponent Size>
VTKM_EXEC_CONT_EXPORT
T dot(const vtkm::Vec<T,Size> &a, const vtkm::Vec<T,Size> &b)
{
T result = a[0]*b[0];
T result = T(a[0]*b[0]);
for (vtkm::IdComponent componentIndex = 1; componentIndex < Size; componentIndex++)
{
result += a[componentIndex]*b[componentIndex];
result = T(result + a[componentIndex]*b[componentIndex]);
}
return result;
}
@ -1067,21 +1067,21 @@ template<typename T>
VTKM_EXEC_CONT_EXPORT
T dot(const vtkm::Vec<T,2> &a, const vtkm::Vec<T,2> &b)
{
return (a[0]*b[0]) + (a[1]*b[1]);
return T((a[0]*b[0]) + (a[1]*b[1]));
}
template<typename T>
VTKM_EXEC_CONT_EXPORT
T dot(const vtkm::Vec<T,3> &a, const vtkm::Vec<T,3> &b)
{
return (a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]);
return T((a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]));
}
template<typename T>
VTKM_EXEC_CONT_EXPORT
T dot(const vtkm::Vec<T,4> &a, const vtkm::Vec<T,4> &b)
{
return (a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]) + (a[3]*b[3]);
return T((a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]) + (a[3]*b[3]));
}
//Integer types of a width less than an integer get implicitly casted to

3
vtkm/cont/ArrayHandleCounting.h
View File

@ -74,7 +74,8 @@ public:
VTKM_EXEC_CONT_EXPORT
ValueType Get(vtkm::Id index) const {
return StartingValue + ValueType(static_cast<ComponentType>(index));
return ValueType(StartingValue +
ValueType(static_cast<ComponentType>(index)));
}
private:

2
vtkm/cont/testing/TestingArrayHandles.h
View File

@ -87,7 +87,7 @@ struct TestingArrayHandles
VTKM_EXEC_EXPORT
void operator()(vtkm::Id index) const
{
this->Portal.Set(index, this->Portal.Get(index)+ T(1));
this->Portal.Set(index, T(this->Portal.Get(index) + T(1)));
}
};

4
vtkm/cont/testing/TestingFancyArrayHandles.h
View File

@ -262,7 +262,7 @@ private:
"Counting Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value),
"Counting Handle Control Failed");
component_value = component_value + ComponentType(1);
component_value = ComponentType(component_value + ComponentType(1));
}
}
};
@ -447,7 +447,7 @@ private:
"Transform Counting Handle Failed");
VTKM_TEST_ASSERT(test_equal(result_v, control_value),
"Transform Counting Handle Control Failed");
component_value = component_value + ComponentType(1);
component_value = ComponentType(component_value + ComponentType(1));
}
}
};

4
vtkm/cont/testing/UnitTestArrayHandleCompositeVector.cxx
View File

@ -44,7 +44,9 @@ vtkm::FloatDefault TestValue3Ids(vtkm::Id index,
vtkm::IdComponent inComponentIndex,
int inArrayId)
{
return index + vtkm::FloatDefault(0.1)*inComponentIndex + vtkm::FloatDefault(0.01)*inArrayId;
return (vtkm::FloatDefault(index) +
0.1f*vtkm::FloatDefault(inComponentIndex) +
0.01f*vtkm::FloatDefault(inArrayId));
}
template<typename ValueType>

2
vtkm/exec/arg/testing/UnitTestFetchArrayDirectIn.cxx
View File

@ -68,7 +68,7 @@ struct FetchArrayDirectInTests
VTKM_TEST_ASSERT(test_equal(value, TestValue(index, T())),
"Got invalid value from Load.");
value = T(2)*value;
value = T(T(2)*value);
// This should be a no-op, but we should be able to call it.
fetch.Store(index, invocation, value);

2
vtkm/testing/Testing.h
View File

@ -397,7 +397,7 @@ vtkm::Vec<T,N> TestValue(vtkm::Id index, vtkm::Vec<T,N>) {
vtkm::Vec<T,N> value;
for (vtkm::IdComponent i = 0; i < N; i++)
{
value[i] = TestValue(index, T()) + T(i + 1);
value[i] = T(TestValue(index, T()) + T(i + 1));
}
return value;
}

3
vtkm/testing/UnitTestMatrix.cxx
View File

@ -55,6 +55,7 @@ struct MatrixTest
static const vtkm::IdComponent NUM_ROWS = NumRow;
static const vtkm::IdComponent NUM_COLS = NumCol;
typedef vtkm::Matrix<T,NUM_ROWS,NUM_COLS> MatrixType;
typedef typename MatrixType::ComponentType ComponentType;
static void BasicCreation()
{
@ -74,7 +75,7 @@ struct MatrixTest
MatrixType value = TestValue(0, MatrixType());
FOR_ROW_COL(matrix)
{
matrix[row][col] = value(row,col)*2;
matrix[row][col] = ComponentType(value(row,col)*2);
}
FOR_ROW_COL(matrix)
{

48
vtkm/testing/UnitTestTypes.cxx
View File

@ -130,16 +130,16 @@ template<typename ComponentType, vtkm::IdComponent Size>
void GeneralVecTypeTest(const vtkm::Vec<ComponentType,Size> &)
{
typedef vtkm::Vec<ComponentType,Size> T;
//grab the number of elements of T
T a, b, c;
typename T::ComponentType s(5);
ComponentType s(5);
for(vtkm::IdComponent i=0; i < T::NUM_COMPONENTS; ++i)
{
a[i]=typename T::ComponentType((i+1)*2);
b[i]=typename T::ComponentType(i+1);
c[i]=typename T::ComponentType((i+1)*2);
a[i]=ComponentType((i+1)*2);
b[i]=ComponentType(i+1);
c[i]=ComponentType((i+1)*2);
}
//verify prefix and postfix increment and decrement
@ -149,36 +149,46 @@ void GeneralVecTypeTest(const vtkm::Vec<ComponentType,Size> &)
c[T::NUM_COMPONENTS-1]--;
//make c nearly like a to verify == and != are correct.
c[T::NUM_COMPONENTS-1]=(c[T::NUM_COMPONENTS-1]-1);
c[T::NUM_COMPONENTS-1]=ComponentType(c[T::NUM_COMPONENTS-1]-1);
T plus = a + b;
T correct_plus;
for(vtkm::IdComponent i=0; i < T::NUM_COMPONENTS; ++i)
{ correct_plus[i] = a[i] + b[i]; }
{
correct_plus[i] = ComponentType(a[i] + b[i]);
}
VTKM_TEST_ASSERT(test_equal(plus, correct_plus),"Tuples not added correctly.");
T minus = a - b;
T correct_minus;
for(vtkm::IdComponent i=0; i < T::NUM_COMPONENTS; ++i)
{ correct_minus[i] = a[i] - b[i]; }
{
correct_minus[i] = ComponentType(a[i] - b[i]);
}
VTKM_TEST_ASSERT(test_equal(minus, correct_minus),"Tuples not subtracted correctly.");
T mult = a * b;
T correct_mult;
for(vtkm::IdComponent i=0; i < T::NUM_COMPONENTS; ++i)
{ correct_mult[i] = a[i] * b[i]; }
{
correct_mult[i] = ComponentType(a[i] * b[i]);
}
VTKM_TEST_ASSERT(test_equal(mult, correct_mult),"Tuples not multiplied correctly.");
T div = a / b;
T correct_div;
for(vtkm::IdComponent i=0; i < T::NUM_COMPONENTS; ++i)
{ correct_div[i] = a[i] / b[i]; }
{
correct_div[i] = ComponentType(a[i] / b[i]);
}
VTKM_TEST_ASSERT(test_equal(div,correct_div),"Tuples not divided correctly.");
mult = s * a;
for(vtkm::IdComponent i=0; i < T::NUM_COMPONENTS; ++i)
{ correct_mult[i] = s * a[i]; }
{
correct_mult[i] = ComponentType(s * a[i]);
}
VTKM_TEST_ASSERT(test_equal(mult, correct_mult),
"Scalar and Tuple did not multiply correctly.");
@ -186,10 +196,12 @@ void GeneralVecTypeTest(const vtkm::Vec<ComponentType,Size> &)
VTKM_TEST_ASSERT(test_equal(mult, correct_mult),
"Tuple and Scalar to not multiply correctly.");
typename T::ComponentType d = vtkm::dot(a, b);
typename T::ComponentType correct_d = 0;
ComponentType d = vtkm::dot(a, b);
ComponentType correct_d = 0;
for(vtkm::IdComponent i=0; i < T::NUM_COMPONENTS; ++i)
{correct_d += a[i] * b[i]; }
{
correct_d = ComponentType(correct_d + a[i] * b[i]);
}
VTKM_TEST_ASSERT(test_equal(d, correct_d), "dot(Tuple) wrong");
VTKM_TEST_ASSERT(!(a < b), "operator< wrong");
@ -411,25 +423,25 @@ void TypeTest(Scalar)
Scalar a = 4;
Scalar b = 2;
Scalar plus = a + b;
Scalar plus = Scalar(a + b);
if (plus != 6)
{
VTKM_TEST_FAIL("Scalars do not add correctly.");
}
Scalar minus = a - b;
Scalar minus = Scalar(a - b);
if (minus != 2)
{
VTKM_TEST_FAIL("Scalars to not subtract correctly.");
}
Scalar mult = a * b;
Scalar mult = Scalar(a * b);
if (mult != 8)
{
VTKM_TEST_FAIL("Scalars to not multiply correctly.");
}
Scalar div = a / b;
Scalar div = Scalar(a / b);
if (div != 2)
{
VTKM_TEST_FAIL("Scalars to not divide correctly.");

9
vtkm/testing/VecTraitsTests.h
View File

@ -62,7 +62,10 @@ static void TestVecTypeImpl(
const ComponentType multiplier = 4;
for (vtkm::IdComponent i = 0; i < NUM_COMPONENTS; i++)
{
Traits::SetComponent(result, i, multiplier*Traits::GetComponent(vector, i));
Traits::SetComponent(result,
i,
ComponentType(
multiplier*Traits::GetComponent(vector, i)));
}
VTKM_TEST_ASSERT(test_equal(Traits::ToVec(result),
multiplier*Traits::ToVec(vector)),
@ -75,7 +78,7 @@ static void TestVecTypeImpl(
for (vtkm::IdComponent i = 0; i < NUM_COMPONENTS; i++)
{
Traits::GetComponent(result, i)
= multiplier * Traits::GetComponent(vector, i);
= ComponentType(multiplier * Traits::GetComponent(vector, i));
}
VTKM_TEST_ASSERT(test_equal(Traits::ToVec(result),
multiplier*Traits::ToVec(vector)),
@ -88,7 +91,7 @@ static void TestVecTypeImpl(
{
ComponentType component
= Traits::GetComponent(vector, i);
result += component * component;
result = ComponentType(result + (component * component));
}
VTKM_TEST_ASSERT(
test_equal(result,