public void Long_Get_Exc_LessThan2Bits_Loopback()
{
BVector d = new BVector();
d.Add(0, 32);
d.GetLong(1);
}
public void LongN_Get_Exc_MoreThan64Bits_Loopback()
{
BVector d = new BVector();
d.Add((long?)0, 32);
d.GetLongN(65);
}
public void DynamicInt()
{
var rnd = new CryptoRandom();
int itemCount = 1_000_000;
int value = 0;
int[] values = new int[itemCount];
BVector d = new BVector();
for (int i = 0; i < itemCount; i++)
{
value = (int)rnd.NextLong(int.MinValue, int.MaxValue);
d.DynamicAdd(value);
d.Add1();
values[i] = value;
}
d.DynamicAdd(int.MinValue);
d.Add1();
d.DynamicAdd(int.MaxValue);
d.Add1();
d.DynamicAdd((int)0);
for (uint i = 0; i < itemCount; i++)
{
Assert.AreEqual(values[i], d.DynamicGetInt());
Assert.AreEqual(true, d.Get1());
}
Assert.AreEqual(int.MinValue, d.DynamicGetInt());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual(int.MaxValue, d.DynamicGetInt());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual((int)0, d.DynamicGetInt());
}
public void DynamicShort()
{
var rnd = new CryptoRandom();
short value = 0;
short[] values = new short[ushort.MaxValue];
int index = 0;
BVector d = new BVector();
for (int i = short.MinValue; i < short.MaxValue; i++)
{
value = (short)rnd.NextLong(short.MinValue, short.MaxValue);
d.DynamicAdd(value);
d.Add1();
values[index++] = (short)value;
}
d.DynamicAdd(short.MinValue);
d.Add1();
d.DynamicAdd(short.MaxValue);
d.Add1();
d.DynamicAdd((short)0);
index = 0;
for (int i = 0; i < values.Length; i++)
{
Assert.AreEqual(values[i], d.DynamicGetShort());
Assert.AreEqual(true, d.Get1());
}
Assert.AreEqual(short.MinValue, d.DynamicGetShort());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual(short.MaxValue, d.DynamicGetShort());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual((short)0, d.DynamicGetShort());
}
public void DynamicSByte()
{
var rnd = new CryptoRandom();
int itemCount = byte.MaxValue;
sbyte value = 0;
sbyte[] values = new sbyte[itemCount];
BVector d = new BVector();
for (uint i = 0; i < itemCount; i++)
{
value = (sbyte)rnd.NextLong(sbyte.MinValue, sbyte.MaxValue);
d.DynamicAdd(value);
d.Add1();
values[i] = value;
}
d.DynamicAdd(sbyte.MinValue);
d.Add1();
d.DynamicAdd(sbyte.MaxValue);
d.Add1();
d.DynamicAdd((sbyte)0);
for (uint i = 0; i < itemCount; i++)
{
Assert.AreEqual(values[i], d.DynamicGetSByte());
Assert.AreEqual(true, d.Get1());
}
Assert.AreEqual(sbyte.MinValue, d.DynamicGetSByte());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual(sbyte.MaxValue, d.DynamicGetSByte());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual((sbyte)0, d.DynamicGetSByte());
}
public void DynamicLong()
{
var rnd = new CryptoRandom();
long itemCount = 1_000_000;
long value = 0;
long[] values = new long[itemCount];
BVector d = new BVector();
for (long i = 0; i < itemCount; i++)
{
value = (long)rnd.NextLong(long.MinValue, long.MaxValue);
d.DynamicAdd(value);
d.Add1();
values[i] = value;
}
d.DynamicAdd(long.MinValue);
d.Add1();
d.DynamicAdd(long.MaxValue);
d.Add1();
d.DynamicAdd((long)0);
for (uint i = 0; i < itemCount; i++)
{
Assert.AreEqual(values[i], d.DynamicGetLong());
Assert.AreEqual(true, d.Get1());
}
Assert.AreEqual(long.MinValue, d.DynamicGetLong());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual(long.MaxValue, d.DynamicGetLong());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual((long)0, d.DynamicGetLong());
}
public void DoubleN_MinMax()
{
BVector d = new BVector();
double? max = double.MaxValue;
double? min = double.MinValue;
double? zero = (double)0;
double? @null = null;
d.Add(max);
d.Add1(false);
d.Add(@null);
d.Add1(true);
d.Add(zero);
d.Add1(false);
d.Add(min);
Assert.AreEqual(max, d.GetDoubleN());
Assert.AreEqual(false, d.Get1());
Assert.AreEqual(@null, d.GetDoubleN());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual(zero, d.GetDoubleN());
Assert.AreEqual(false, d.Get1());
Assert.AreEqual(min, d.GetDoubleN());
}
public BVector(BVector other) : this(yarpPINVOKE.new_BVector__SWIG_1(BVector.getCPtr(other)), true)
{
if (yarpPINVOKE.SWIGPendingException.Pending)
{
throw yarpPINVOKE.SWIGPendingException.Retrieve();
}
}
public void Basic_64_AddGet_Safe_RedirectTo32_Loopback()
{
BVector d = new BVector();
d.AddU64((ulong)1, 32);
Assert.AreEqual((ulong)1, d.GetU64(32));
}
public void Basic_8_AddGet_Safe_Random_InOut()
{
int index = 0;
byte maxValue = byte.MaxValue;
byte value;
byte expected;
var rnd = new CryptoRandom();
List <byte> values = new List <byte>();
// number of items to add per bit
int itemsCount = 1_000;
BVector d = new BVector();
for (int i = 0; i < itemsCount; i++)
{
value = (byte)rnd.NextLong(maxValue);
d.Add8(value);
values.Add(value);
// add 1 bit to split bytes
d.Add1(false);
}
BVector d2 = new BVector(d.ToBytes());
for (int i = 0; i < itemsCount; i++)
{
value = d2.Get8();
expected = values[index];
Assert.AreEqual(expected, value);
Assert.AreEqual(false, d2.Get1());
index++;
}
}
public void Basic_64_AddGet_Safe_Random_InOut()
{
var rnd = new CryptoRandom();
List <ulong> values = new List <ulong>();
ulong value;
int valueCount = 1_000;
BVector d = new BVector();
for (int i = 0; i < valueCount; i++)
{
value = (ulong)rnd.NextLong(int.MaxValue, long.MaxValue);
d.AddU64(value);
values.Add(value);
// add 1 bit to split bytes
d.Add1(false);
}
BVector d2 = new BVector(d.ToBytes());
for (int i = 0; i < valueCount; i++)
{
Assert.AreEqual(values[i], d2.GetU64());
Assert.AreEqual(false, d2.Get1());
}
}
public void Solve()
{
Matrix coefficients = new Matrix(NUnknown.Value, NUnknown.Value);
for (int i = 0; i != CoefficientMatrix.Count; ++i)
{
for (int j = 0; j != CoefficientMatrix[i].Count; ++j)
{
coefficients[i, j] = CoefficientMatrix[i][j].Val;
}
}
//xxx check for nulls
double[] b = BVector.Select(x => x.Val).ToArray();
double[] solution;
bool success = _model.Solve(coefficients, b, out solution);
if (success)
{
var builder = new StringBuilder();
for (int i = 0; i != solution.Length; ++i)
{
builder.Append(Unknowns[i] + " = " + solution[i] + "\n");
}
SolutionText = builder.ToString();
}
else
{
SolutionText = "Singular coefficient matrix";
}
}
public void DynamicUShort()
{
var rnd = new CryptoRandom();
int itemCount = ushort.MaxValue;
ushort value = 0;
ushort[] values = new ushort[itemCount];
BVector d = new BVector();
for (uint i = 0; i < itemCount; i++)
{
value = (ushort)rnd.NextLong(0, ushort.MaxValue);
d.DynamicAdd(value);
d.Add1();
values[i] = value;
}
d.DynamicAdd(ushort.MinValue);
d.Add1();
d.DynamicAdd(ushort.MaxValue);
for (uint i = 0; i < itemCount; i++)
{
Assert.AreEqual(values[i], d.DynamicGetUShort());
Assert.AreEqual(true, d.Get1());
}
Assert.AreEqual(ushort.MinValue, d.DynamicGetUShort());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual(ushort.MaxValue, d.DynamicGetUShort());
}
public void Ext_UIntN_Get_Exc_MoreThan32Bits_Loopback()
{
BVector d = new BVector();
d.Add((uint?)0, 32);
d.GetUIntN(33);
}
public void Basic_1_AddGet_RandomSequence_InOut()
{
var rnd = new CryptoRandom();
bool value;
List <bool> values = new List <bool>();
int bitCount = 1_000;
BVector d = new BVector();
// create sequenece and add
for (int i = 0; i < bitCount; i++)
{
value = rnd.Next(100) > 50;
values.Add(value);
d.Add1(value);
}
BVector d2 = new BVector(d.ToBytes());
Assert.AreEqual(d.ToBytes().SequenceEqual(d2.ToBytes()), true);
// verify
for (int i = 0; i < bitCount; i++)
{
Assert.AreEqual(values[i], d2.Get1());
}
}
public BVectorEnumerator(BVector collection)
{
collectionRef = collection;
currentIndex = -1;
currentObject = null;
currentSize = collectionRef.Count;
}
public void Int_AddGet_BitsMinMax_Separated_Loopback()
{
int maxBits = 32;
List<int> values = new List<int>();
BVector d = new BVector();
int positiveValue;
int negativeValue;
int actualValue;
int index;
int expected;
int maxVal = int.MaxValue;
byte bits;
// add min and max values for 2-32 bits
for (int i = 0; i < (maxBits - 1); i++)
{
bits = (byte)(maxBits - i);
positiveValue = maxVal >> i;
negativeValue = -positiveValue - 1;
// add positive
d.Add(positiveValue, bits);
values.Add(positiveValue);
// true separator
d.Add1();
// add negative
d.Add(negativeValue, bits);
values.Add(negativeValue);
// false separator
d.Add1(false);
}
// get min and max values for 2-32 bits
index = 0;
for (int i = 0; i < (maxBits - 1); i++)
{
bits = (byte)(maxBits - i);
// get positive
expected = values[index++];
actualValue = d.GetInt(bits);
Assert.AreEqual(expected, actualValue);
// true separator
Assert.AreEqual(true, d.Get1());
// get min
expected = values[index++];
actualValue = d.GetInt(bits);
Assert.AreEqual(expected, actualValue);
// false separator
Assert.AreEqual(false, d.Get1());
}
}
public void Combo1()
{
object val = null;
object testValue = null;
BVector d = new BVector();
int itemCount = 1000;
object[] values = new object[itemCount];
for (int i = 0; i < itemCount; i++)
{
val = BHelper.WriteRandomValue(d);
values[i] = val;
}
for (int i = 0; i < itemCount; i++)
{
val = values[i];
testValue = BHelper.ReadNextRandomValue(d);
var valueType = val.GetType();
// Assert.AreEqual cannot compare byte[] since it is using reference equality
if (valueType.IsArray && valueType.GetElementType() == typeof(byte))
{
Assert.IsTrue(BHelper.CompareByteArrays((byte[])val, (byte[])testValue));
}
else
{
Assert.AreEqual(val, testValue);
}
}
}
public void Ext_ShortN_Get_Exc_LessThan2Bits_Loopback()
{
BVector d = new BVector();
d.Add((short?)0, 16);
d.GetShortN(1);
}
public void Ext_UIntN_Get_Exc_LessThan2Bits_Loopback()
{
BVector d = new BVector();
d.Add((uint?)0, 32);
d.GetUIntN(1);
}
public void SerialAddGetAll()
{
var rnd = new CryptoRandom();
// using 2 BVectors cause of the extensive length required
BVector d = new BVector();
BVector d2 = new BVector();
for (ushort i = 0; i < ushort.MaxValue; i++)
{
if (i % 2 == 0)
{
d.SerialAdd(i);
d.Add1(rnd.Next(100) < 50);
}
else
{
d2.SerialAdd(i);
d2.Add1(rnd.Next(100) < 50);
}
}
for (ushort i = 0; i < ushort.MaxValue; i++)
{
if (i % 2 == 0)
{
Assert.AreEqual(d.SerialGet(), i);
d.Get1();
}
else
{
Assert.AreEqual(d2.SerialGet(), i);
d2.Get1();
}
}
}
public void Ext_ShortN_Get_Exc_MoreThan16Bits_Loopback()
{
BVector d = new BVector();
d.Add((short?)0, 16);
d.GetShortN(17);
}
public void Ext_ULongN_Get_Exc_MoreThan32Bits_Loopback()
{
BVector d = new BVector();
d.Add((ulong?)0, 32);
d.GetULongN(65);
}
public void Ext_Short_Get_Exc_LessThan2Bits_Loopback()
{
BVector d = new BVector();
d.Add((short)0, 32);
d.GetShort(1);
}
public void Ext_ULongN_Get_Exc_LessThan2Bits_Loopback()
{
BVector d = new BVector();
d.Add((ulong?)0, 32);
d.GetULongN(1);
}
public void Decimal_Rnd()
{
BVector d = new BVector();
decimal value;
const decimal maxValue = decimal.MaxValue;
const decimal minValue = decimal.MinValue;
var rnd = new CryptoRandom();
List <decimal> values = new List <decimal>();
// number of items to add per bit
int itemsCount = 1_000;
for (int i = 0; i < itemsCount; i++)
{
// add positive
value = (decimal)rnd.NextDouble() * maxValue;
d.Add(value);
values.Add(value);
d.Add1(false);
// add negative
value = (decimal)rnd.NextDouble() * minValue;
d.Add(value);
values.Add(value);
d.Add1(true);
}
for (int i = 0; i < itemsCount; i++)
{
value = d.GetDecimal();
Assert.AreEqual(values[i], value);
Assert.AreEqual(i % 2 != 0, d.Get1());
}
}
public void DecimalN_MinMax()
{
BVector d = new BVector();
decimal? max = decimal.MaxValue;
decimal? min = decimal.MinValue;
decimal? zero = (decimal)0;
decimal? @null = null;
d.Add(max);
d.Add1(false);
d.Add(@null);
d.Add1(true);
d.Add(zero);
d.Add1(false);
d.Add(min);
Assert.AreEqual(max, d.GetDecimalN());
Assert.AreEqual(false, d.Get1());
Assert.AreEqual(@null, d.GetDecimalN());
Assert.AreEqual(true, d.Get1());
Assert.AreEqual(zero, d.GetDecimalN());
Assert.AreEqual(false, d.Get1());
Assert.AreEqual(min, d.GetDecimalN());
}
public void Basic_32_AddGet_UintMinMaxZero_InOut()
{
List <uint> values = new List <uint>();
BVector d = new BVector();
d.AddU32(uint.MinValue);
d.AddU32(uint.MaxValue);
d.AddU32(0);
// add 1 bit to test byte split
d.Add1(false);
d.AddU32(uint.MinValue);
d.AddU32(uint.MaxValue);
d.AddU32(0);
BVector d2 = new BVector(d.ToBytes());
Assert.AreEqual(uint.MinValue, d2.GetU32());
Assert.AreEqual(uint.MaxValue, d2.GetU32());
Assert.AreEqual((uint)0, d2.GetU32());
Assert.AreEqual(false, d2.Get1());
Assert.AreEqual(uint.MinValue, d2.GetU32());
Assert.AreEqual(uint.MaxValue, d2.GetU32());
Assert.AreEqual((uint)0, d2.GetU32());
}
public Ball(int size, float speed, float
defaultBallBumpSpeedIncreaseFactor) : base(size, size)
{
Speed = speed;
BumpSpeedIncreaseFactor = defaultBallBumpSpeedIncreaseFactor;
// Initial direction
Direction = new BVector(BVector.ArrowDir.SE);
}
public void SetRange(int index, BVector values)
{
yarpPINVOKE.BVector_SetRange(swigCPtr, index, BVector.getCPtr(values));
if (yarpPINVOKE.SWIGPendingException.Pending)
{
throw yarpPINVOKE.SWIGPendingException.Retrieve();
}
}
public bool checkMotionDone(int i, BVector flag)
{
bool ret = yarpPINVOKE.IPositionControl_checkMotionDone__SWIG_4(swigCPtr, i, BVector.getCPtr(flag));
if (yarpPINVOKE.SWIGPendingException.Pending) throw yarpPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
