195 lines
6.7 KiB
C#
195 lines
6.7 KiB
C#
using System;
|
|
|
|
namespace KKdMainLib
|
|
{
|
|
public static class MathExtensions
|
|
{
|
|
public static void FloorCeiling( ref double Value) =>
|
|
Value = Value % 1 >= 0.5 ? (long)(Value + 0.5) : (long) Value;
|
|
|
|
public static long FloorCeiling(this double Value) =>
|
|
Value % 1 >= 0.5 ? (long)(Value + 0.5) : (long) Value;
|
|
|
|
public static int Align(this int value, int alignement, int divide = 1) =>
|
|
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
|
|
|
public static uint Align(this uint value, uint alignement, uint divide = 1) =>
|
|
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
|
|
|
public static long Align(this long value, long alignement, long divide = 1) =>
|
|
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
|
|
|
public static ulong Align(this ulong value, ulong alignement, ulong divide = 1) =>
|
|
((value % alignement == 0) ? value : (value + alignement - value % alignement)) / divide;
|
|
|
|
public static byte[] buf = new byte[8];
|
|
public static unsafe byte* bufPtr = buf.GetPtr();
|
|
|
|
public static unsafe long Endian(this long LE, byte Len, bool IsBE)
|
|
{ if (IsBE) { for (byte i = 0; i < Len; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
|
for (byte i = 0; i < Len; i++) { LE |= bufPtr[i]; if (i < Len - 1) LE <<= 8; } } return LE; }
|
|
|
|
public static unsafe ulong Endian(this ulong LE, byte Len, bool IsBE)
|
|
{ if (IsBE) { for (byte i = 0; i < Len; i++) { bufPtr[i] = (byte)LE; LE >>= 8; } LE = 0;
|
|
for (byte i = 0; i < Len; i++) { LE |= bufPtr[i]; if (i < Len - 1) LE <<= 8; } } return LE; }
|
|
|
|
public static sbyte CITSB(this int c)
|
|
{
|
|
if (c > 0x7F) c = 0x7F;
|
|
else if (c < -0x80) c = -0x80;
|
|
return (sbyte)c;
|
|
}
|
|
|
|
public static byte CITB(this int c)
|
|
{
|
|
if (c > 0xFF) c = 0xFF;
|
|
else if (c < 0x00) c = 0x00;
|
|
return (byte)c;
|
|
}
|
|
|
|
public static short CITS(this int c)
|
|
{
|
|
if (c > 0x7FFF) c = 0x7FFF;
|
|
else if (c < -0x8000) c = -0x8000;
|
|
return (short)c;
|
|
}
|
|
|
|
public static ushort CITUS(this int c)
|
|
{
|
|
if (c > 0xFFFF) c = 0xFFFF;
|
|
else if (c < 0x0000) c = 0x0000;
|
|
return (ushort)c;
|
|
}
|
|
|
|
public static sbyte CFTSB(this float c)
|
|
{
|
|
c = c.Round();
|
|
if (c > 0x7F) c = 0x7F;
|
|
else if (c < -0x80) c = -0x80;
|
|
return (sbyte)c;
|
|
}
|
|
|
|
public static byte CFTB(this float c)
|
|
{
|
|
c = c.Round();
|
|
if (c > 0xFF) c = 0xFF;
|
|
else if (c < 0x00) c = 0x00;
|
|
return (byte)c;
|
|
}
|
|
|
|
public static short CFTS(this float c)
|
|
{
|
|
c = c.Round();
|
|
if (c > 0x7FFF) c = 0x7FFF;
|
|
else if (c < -0x8000) c = -0x8000;
|
|
return (short)c;
|
|
}
|
|
|
|
public static ushort CFTUS(this float c)
|
|
{
|
|
c = c.Round();
|
|
if (c > 0xFFFF) c = 0xFFFF;
|
|
else if (c < 0x0000) c = 0x0000;
|
|
return (ushort)c;
|
|
}
|
|
|
|
public static int CFTI(this float c)
|
|
{
|
|
c = c.Round();
|
|
if (c > 0x7FFFFFFF) c = 0x7FFFFFFF;
|
|
else if (c < -0x80000000) c = -0x80000000;
|
|
return (int)c;
|
|
}
|
|
|
|
public static uint CFTUI(this float c)
|
|
{
|
|
c = c.Round();
|
|
if (c > 0xFFFFFFFF) c = 0xFFFFFFFF;
|
|
else if (c < 0x00000000) c = 0x00000000;
|
|
return (uint)c;
|
|
}
|
|
|
|
public static float Round(this float c) => (float)Math.Round(c);
|
|
|
|
public static sbyte CFTSB(this double c)
|
|
{
|
|
c = Math.Round(c);
|
|
if (c > 0x7F) c = 0x7F;
|
|
else if (c < -0x80) c = -0x80;
|
|
return (sbyte)c;
|
|
}
|
|
|
|
public static byte CFTB(this double c)
|
|
{
|
|
c = Math.Round(c);
|
|
if (c > 0xFF) c = 0xFF;
|
|
else if (c < 0x00) c = 0x00;
|
|
return (byte)c;
|
|
}
|
|
|
|
public static short CFTS(this double c)
|
|
{
|
|
c = Math.Round(c);
|
|
if (c > 0x7FFF) c = 0x7FFF;
|
|
else if (c < -0x8000) c = -0x8000;
|
|
return (short)c;
|
|
}
|
|
|
|
public static ushort CFTUS(this double c)
|
|
{
|
|
c = Math.Round(c);
|
|
if (c > 0xFFFF) c = 0xFFFF;
|
|
else if (c < 0x0000) c = 0x0000;
|
|
return (ushort)c;
|
|
}
|
|
|
|
public static int CFTI(this double c)
|
|
{
|
|
c = Math.Round(c);
|
|
if (c > 0x7FFFFFFF) c = 0x7FFFFFFF;
|
|
else if (c < -0x80000000) c = -0x80000000;
|
|
return (int)c;
|
|
}
|
|
|
|
public static uint CFTUI(this double c)
|
|
{
|
|
c = Math.Round(c);
|
|
if (c > 0xFFFFFFFF) c = 0xFFFFFFFF;
|
|
else if (c < 0x00000000) c = 0x00000000;
|
|
return (uint)c;
|
|
}
|
|
|
|
public static double Round(this double c, int d = 0) => Math.Round(c, d);
|
|
|
|
public static unsafe sbyte* GetPtr(this sbyte[] array)
|
|
{ sbyte* Ptr; fixed ( sbyte* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe byte* GetPtr(this byte[] array)
|
|
{ byte* Ptr; fixed ( byte* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe short* GetPtr(this short[] array)
|
|
{ short* Ptr; fixed ( short* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe ushort* GetPtr(this ushort[] array)
|
|
{ ushort* Ptr; fixed (ushort* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe int* GetPtr(this int[] array)
|
|
{ int* Ptr; fixed ( int* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe uint* GetPtr(this uint[] array)
|
|
{ uint* Ptr; fixed ( uint* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe long* GetPtr(this long[] array)
|
|
{ long* Ptr; fixed ( long* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe ulong* GetPtr(this ulong[] array)
|
|
{ ulong* Ptr; fixed ( ulong* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe float* GetPtr(this float[] array)
|
|
{ float* Ptr; fixed ( float* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
|
|
public static unsafe double* GetPtr(this double[] array)
|
|
{ double* Ptr; fixed (double* tempPtr = array) Ptr = tempPtr; return Ptr; }
|
|
}
|
|
}
|