/** {@inheritDoc} */
@Override
protected void checkY(final int step, final AbstractMatrix y) {
super.checkY(step, y);
Assert.assertTrue(y.isIntegerMatrix());
Assert.assertEquals(y.n(), 1);
switch (step) {
case 0:
{
Assert.assertEquals(10L, y.getLong(0, 0));
return;
}
case 1:
{
Assert.assertEquals(20L, y.getLong(0, 0));
return;
}
case 2:
{
Assert.assertEquals(30L, y.getLong(0, 0));
return;
}
case 3:
{
Assert.assertEquals(40L, y.getLong(0, 0));
return;
}
default:
{
throw new AssertionError("Only four steps allowed."); // $NON-NLS-1$
}
}
}
/** {@inheritDoc} */
@Override
protected void checkX(final int step, final BasicNumber x) {
super.checkX(step, x);
Assert.assertTrue(x.isInteger());
switch (step) {
case 0:
{
Assert.assertEquals(0L, x.longValue());
return;
}
case 1:
{
Assert.assertEquals(1L, x.longValue());
return;
}
case 2:
{
Assert.assertEquals(2L, x.longValue());
return;
}
case 3:
{
Assert.assertEquals(3L, x.longValue());
return;
}
default:
{
throw new AssertionError("Only four steps allowed."); // $NON-NLS-1$
}
}
}
/** {@inheritDoc} */
@Override
protected void checkX(final int step, final BasicNumber x) {
super.checkX(step, x);
Assert.assertFalse(x.isInteger());
if (step <= 15) {
Assert.assertEquals(-step - 0.5d, x.doubleValue(), Double.MIN_VALUE);
} else {
throw new AssertionError("Only sixteen steps allowed."); // $NON-NLS-1$
}
}
/** {@inheritDoc} */
@Override
protected void checkY(final int step, final AbstractMatrix y) {
super.checkY(step, y);
Assert.assertFalse(y.isIntegerMatrix());
Assert.assertEquals(y.n(), 1);
switch (step) {
case 0:
{
Assert.assertEquals(-100.5d, y.getDouble(0, 0), Double.MIN_VALUE);
return;
}
case 1:
{
Assert.assertEquals(10.5d, y.getDouble(0, 0), Double.MIN_VALUE);
return;
}
case 2:
{
Assert.assertEquals(20.5d, y.getDouble(0, 0), Double.MIN_VALUE);
return;
}
case 3:
{
Assert.assertEquals(30.5d, y.getDouble(0, 0), Double.MIN_VALUE);
return;
}
case 4:
{
Assert.assertEquals(40.5d, y.getDouble(0, 0), Double.MIN_VALUE);
return;
}
default:
{
throw new AssertionError("Only five steps allowed."); // $NON-NLS-1$
}
}
}
/** {@inheritDoc} */
@Override
protected void checkX(final int step, final BasicNumber x) {
super.checkX(step, x);
Assert.assertFalse(x.isInteger());
switch (step) {
case 0:
{
Assert.assertEquals(40000.5d, x.doubleValue(), Double.MIN_VALUE);
return;
}
case 1:
{
Assert.assertEquals(3.5d, x.doubleValue(), Double.MIN_VALUE);
return;
}
case 2:
{
Assert.assertEquals(2.5d, x.doubleValue(), Double.MIN_VALUE);
return;
}
case 3:
{
Assert.assertEquals(1.5d, x.doubleValue(), Double.MIN_VALUE);
return;
}
case 4:
{
Assert.assertEquals(0.5d, x.doubleValue(), Double.MIN_VALUE);
return;
}
default:
{
throw new AssertionError("Only five steps allowed."); // $NON-NLS-1$
}
}
}
/** {@inheritDoc} */
@Override
protected void checkState(final int step, final MatrixIteration2DState state) {
super.checkState(step, state);
Assert.assertEquals(1, state.getSourceMatrixCount());
Assert.assertEquals(0, state.getSourceMatrixIndex(0));
}
/** {@inheritDoc} */
@Override
protected void checkTotalSteps(final int totalSteps) {
super.checkTotalSteps(totalSteps);
Assert.assertEquals(5, totalSteps);
}
/** {@inheritDoc} */
@Override
protected void checkState(final int step, final MatrixIteration2DState state) {
super.checkState(step, state);
switch (step) {
case 0:
{
Assert.assertEquals(1, state.getSourceMatrixCount());
Assert.assertEquals(0, state.getSourceMatrixIndex(0));
return;
}
case 1:
{
Assert.assertEquals(2, state.getSourceMatrixCount());
Assert.assertEquals(0, state.getSourceMatrixIndex(0));
Assert.assertEquals(1, state.getSourceMatrixIndex(1));
return;
}
case 2:
{
Assert.assertEquals(3, state.getSourceMatrixCount());
Assert.assertEquals(0, state.getSourceMatrixIndex(0));
Assert.assertEquals(1, state.getSourceMatrixIndex(1));
Assert.assertEquals(2, state.getSourceMatrixIndex(2));
return;
}
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 12:
{
Assert.assertEquals(4, state.getSourceMatrixCount());
Assert.assertEquals(0, state.getSourceMatrixIndex(0));
Assert.assertEquals(1, state.getSourceMatrixIndex(1));
Assert.assertEquals(2, state.getSourceMatrixIndex(2));
Assert.assertEquals(3, state.getSourceMatrixIndex(3));
return;
}
case 13:
{
Assert.assertEquals(3, state.getSourceMatrixCount());
Assert.assertEquals(1, state.getSourceMatrixIndex(0));
Assert.assertEquals(2, state.getSourceMatrixIndex(1));
Assert.assertEquals(3, state.getSourceMatrixIndex(2));
return;
}
case 14:
{
Assert.assertEquals(2, state.getSourceMatrixCount());
Assert.assertEquals(2, state.getSourceMatrixIndex(0));
Assert.assertEquals(3, state.getSourceMatrixIndex(1));
return;
}
case 15:
{
Assert.assertEquals(1, state.getSourceMatrixCount());
Assert.assertEquals(3, state.getSourceMatrixIndex(0));
return;
}
default:
{
throw new AssertionError("Only sixteen steps allowed."); // $NON-NLS-1$
}
}
}
/** {@inheritDoc} */
@Override
protected void checkY(final int step, final AbstractMatrix y) {
super.checkY(step, y);
Assert.assertFalse(y.isIntegerMatrix());
switch (step) {
case 0:
{
Assert.assertEquals(y.n(), 1);
Assert.assertEquals(0.5d, y.getDouble(0, 0), Double.MIN_VALUE);
return;
}
case 1:
{
Assert.assertEquals(y.n(), 2);
Assert.assertEquals(0.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(100.5d, y.getDouble(0, 1), Double.MIN_VALUE);
return;
}
case 2:
{
Assert.assertEquals(y.n(), 3);
Assert.assertEquals(0.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(100.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(20000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
return;
}
case 3:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(0.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(100.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(20000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(3000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 4:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(4.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(100.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(20000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(3000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 5:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(4.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(500.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(20000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(3000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 6:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(4.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(500.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(60000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(3000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 7:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(4.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(500.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(60000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(7000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 8:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(8.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(500.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(60000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(7000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 9:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(8.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(900.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(60000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(7000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 10:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(8.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(900.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(100000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(7000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 11:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(8.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(900.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(100000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(11000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 12:
{
Assert.assertEquals(y.n(), 4);
Assert.assertEquals(12.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(900.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(100000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
Assert.assertEquals(11000000.5d, y.getDouble(0, 3), Double.MIN_VALUE);
return;
}
case 13:
{
Assert.assertEquals(y.n(), 3);
Assert.assertEquals(1300.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(100000.5d, y.getDouble(0, 1), Double.MIN_VALUE);
Assert.assertEquals(11000000.5d, y.getDouble(0, 2), Double.MIN_VALUE);
return;
}
case 14:
{
Assert.assertEquals(y.n(), 2);
Assert.assertEquals(140000.5d, y.getDouble(0, 0), Double.MIN_VALUE);
Assert.assertEquals(11000000.5d, y.getDouble(0, 1), Double.MIN_VALUE);
return;
}
case 15:
{
Assert.assertEquals(y.n(), 1);
Assert.assertEquals(15000000.5d, y.getDouble(0, 0), Double.MIN_VALUE);
return;
}
default:
{
throw new AssertionError("Only sixteen steps allowed."); // $NON-NLS-1$
}
}
}
