public OrderedArray1d(Type type, bool ordered)
: base(1, type)
{
if (ordered && TypeUtils.IsNumeric(type))
{
order = ArrayOrder.Unknown;
}
else
{
order = ArrayOrder.None;
}
}
private void SetUpOrder(Array a)
{
if (a.Length <= 1)
{
return;
}
int res = GetOrder(a);
if (res == 0)
{
throw new Exception("Axis must be strictly monotonic.");
}
order = (res > 0) ? ArrayOrder.Ascendant : ArrayOrder.Descendant;
}
public void EnforceOrder(bool enforce)
{
if (!TypeUtils.IsNumeric(type) && !TypeUtils.IsDateTime(type) && !(type == typeof(string)))
{
return;
}
if (enforce)
{
order = ArrayOrder.Unknown;
}
else
{
order = ArrayOrder.None;
}
}
/// <summary>
/// Determines the order of the array.
/// </summary>
public static ArrayOrder IsOrdered <T>(T[] a)
{
if (a == null || a.Length <= 1)
{
return(ArrayOrder.Unknown);
}
Comparer c = Comparer.DefaultInvariant;
int diff = c.Compare(a[1], a[0]);
if (diff == 0)
{
return(ArrayOrder.None);
}
ArrayOrder order = (diff > 0) ? ArrayOrder.Ascendant : ArrayOrder.Descendant;
if (order == ArrayOrder.Ascendant)
{
for (int i = 1; i < a.Length - 1; i++)
{
if (c.Compare(a[i + 1], a[i]) <= 0)
{
return(ArrayOrder.None);
}
}
}
else if (order == ArrayOrder.Descendant)
{
for (int i = 1; i < a.Length - 1; i++)
{
if (c.Compare(a[i + 1], a[i]) >= 0)
{
return(ArrayOrder.None);
}
}
}
return(order);
}
/// <summary>
/// Determines the order of the array.
/// </summary>
public static ArrayOrder IsOrdered(Array a)
{
if (a == null || a.Length <= 1)
{
return(ArrayOrder.Unknown);
}
int diff = GetOrder(a);
if (diff == 0)
{
return(ArrayOrder.None);
}
ArrayOrder order = (diff > 0) ? ArrayOrder.Ascendant : ArrayOrder.Descendant;
Comparer cmp = Comparer.DefaultInvariant;
if (order == ArrayOrder.Ascendant)
{
for (int i = 0; i < a.Length - 1; i++)
{
if (cmp.Compare(a.GetValue(i + 1), a.GetValue(i)) <= 0)
{
return(ArrayOrder.None);
}
}
}
else if (order == ArrayOrder.Descendant)
{
for (int i = 0; i < a.Length - 1; i++)
{
if (cmp.Compare(a.GetValue(i + 1), a.GetValue(i)) >= 0)
{
return(ArrayOrder.None);
}
}
}
return(order);
}
public static bool IspixelformatAlpha(uint format)
{
if (IspixelformatPacked(format))
{
PackedOrder pOrder =
(PackedOrder)Pixelorder(format);
return(pOrder == PackedOrder.PackedorderArgb ||
pOrder == PackedOrder.PackedorderRgba ||
pOrder == PackedOrder.PackedorderAbgr ||
pOrder == PackedOrder.PackedorderBgra);
}
else if (IspixelformatArray(format))
{
ArrayOrder aOrder =
(ArrayOrder)Pixelorder(format);
return(aOrder == ArrayOrder.ArrayorderArgb ||
aOrder == ArrayOrder.ArrayorderRgba ||
aOrder == ArrayOrder.ArrayorderAbgr ||
aOrder == ArrayOrder.ArrayorderBgra);
}
return(false);
}
private void EmitWriteArray(ILGenerator gen,
TypeInformation typeInformation,
Action loadWriter,
Action loadValue,
Action loadSerializer,
Action loadRemotingEndPoint,
ArrayOrder order = ArrayOrder.Forward)
{
var elementType = typeInformation.ElementType;
var length = gen.DeclareLocal(typeof(int));
var i = gen.DeclareLocal(typeof(int));
var loop = gen.DefineLabel();
var end = gen.DefineLabel();
// writer.Write(value.Length)
loadValue();
gen.Emit(OpCodes.Ldlen);
gen.Emit(OpCodes.Stloc, length);
loadWriter();
gen.Emit(OpCodes.Ldloc, length);
gen.Emit(OpCodes.Call, Methods.WriteInt32);
// i = 0
// OR
// i = length-1
switch (order)
{
case ArrayOrder.Forward:
gen.Emit(OpCodes.Ldc_I4_0);
gen.Emit(OpCodes.Stloc, i);
break;
case ArrayOrder.Reverse:
gen.Emit(OpCodes.Ldloc, length);
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Sub);
gen.Emit(OpCodes.Stloc, i);
break;
default:
throw new InvalidEnumArgumentException(nameof(order), (int)order, typeof(ArrayOrder));
}
gen.MarkLabel(loop);
// while i != length
// OR
// while i != -1
switch (order)
{
case ArrayOrder.Forward:
gen.Emit(OpCodes.Ldloc, length);
gen.Emit(OpCodes.Ldloc, i);
gen.Emit(OpCodes.Ceq);
gen.Emit(OpCodes.Brtrue, end);
break;
default:
gen.Emit(OpCodes.Ldc_I4_0);
gen.Emit(OpCodes.Ldloc, i);
gen.Emit(OpCodes.Cgt);
gen.Emit(OpCodes.Brtrue, end);
break;
}
Action loadCurrentValue = () =>
{
loadValue();
gen.Emit(OpCodes.Ldloc, i);
gen.Emit(OpCodes.Ldelem, elementType);
};
Action loadCurrentValueAddress = () =>
{
loadValue();
gen.Emit(OpCodes.Ldloc, i);
gen.Emit(OpCodes.Ldelema, elementType);
};
EmitWriteValue(gen,
loadWriter,
loadCurrentValue,
loadCurrentValueAddress,
loadSerializer,
loadRemotingEndPoint,
elementType);
switch (order)
{
case ArrayOrder.Forward:
gen.Emit(OpCodes.Ldloc, i);
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Add);
gen.Emit(OpCodes.Stloc, i);
break;
default:
gen.Emit(OpCodes.Ldloc, i);
gen.Emit(OpCodes.Ldc_I4_1);
gen.Emit(OpCodes.Sub);
gen.Emit(OpCodes.Stloc, i);
break;
}
// goto loop
gen.Emit(OpCodes.Br, loop);
gen.MarkLabel(end);
}
