public void Update(Game game)
{
if (firstRun)
{
Round.Start(game);
firstRun = false;
}
Round?.Update(game);
if (game.InputAction?.Type != InputActionType.RoundButton &&
Round != null &&
!Round.RoundEnd)
{
return;
}
Round?.Stop(game);
Round.RoundEnd = false;
RoundMode += 1;
RoundMode = (RoundMode)((int)RoundMode % maxRoundMode);
Round = rounds.FirstOrDefault(x => x.Round == RoundMode);
Round?.Start(game);
roundModeCell.Text = ("RoundMode: " + RoundMode).PadRight(20, ' ');
}
public static double Round(this double d, int place, RoundMode mode)
{
double a = (10).Pow(place);
double[] addValues = { 0.9, 0.5, 0 };
double d1 = (d * a + addValues[(int)mode]).KillDecimal();
return d1.Divide(a);
}
/// <summary>
/// Round specified value to divisor, with mode.
/// Examples:
/// _RoundToDivisor(156, 100, Math) = 200;
/// _RoundToDivisor(1645, 100, Ceiling) = 1700;
/// _RoundToDivisor(1645, 300, Ceiling) = 1800;
/// _RoundToDivisor(59140, 900, Math) = 59400 (time in seconds: 16:25:40, 15 minute, Math = 16:30:00)
/// </summary>
/// <param name="value"></param>
/// <param name="divisor"></param>
/// <param name="mode"></param>
/// <returns></returns>
private static double _RoundToDivisor(double value, double divisor, RoundMode mode)
{
double result = value;
if (divisor > 0d)
{
double count = value / divisor;
switch (mode)
{
case RoundMode.Floor:
count = Math.Floor(count);
break;
case RoundMode.Math:
count = Math.Round(count, 0, MidpointRounding.AwayFromZero);
break;
case RoundMode.Ceiling:
count = Math.Ceiling(count);
break;
}
result = count * divisor;
}
return(result);
}
private static double RoundInternal(double value, RoundMode mode)
{
double tmp_value;
if (value >= 0.0)
{
tmp_value = Math.Floor(value + 0.5);
if (mode != RoundMode.HalfUp)
{
if ((mode == RoundMode.HalfDown && value == (-0.5 + tmp_value)) ||
(mode == RoundMode.HalfEven && value == (0.5 + 2 * Math.Floor(tmp_value * .5))) ||
(mode == RoundMode.HalfOdd && value == (0.5 + 2 * Math.Floor(tmp_value * .5) - 1.0)))
{
tmp_value = tmp_value - 1.0;
}
}
}
else
{
tmp_value = Math.Ceiling(value - 0.5);
if (mode != RoundMode.HalfUp)
{
if ((mode == RoundMode.HalfDown && value == (0.5 + tmp_value)) ||
(mode == RoundMode.HalfEven && value == (-0.5 + 2 * Math.Ceiling(tmp_value * .5))) ||
(mode == RoundMode.HalfOdd && value == (-0.5 + 2 * Math.Ceiling(tmp_value * .5) + 1.0)))
{
tmp_value = tmp_value + 1.0;
}
}
}
return(tmp_value);
}
public static Vector128 <float> Sse41VectorRoundF(Vector128 <float> value, CpuThreadState state)
{
if (!Sse41.IsSupported)
{
throw new PlatformNotSupportedException();
}
RoundMode roundMode = state.FPRoundingMode();
if (roundMode == RoundMode.ToNearest)
{
return(Sse41.RoundToNearestInteger(value)); // even
}
else if (roundMode == RoundMode.TowardsPlusInfinity)
{
return(Sse41.RoundToPositiveInfinity(value));
}
else if (roundMode == RoundMode.TowardsMinusInfinity)
{
return(Sse41.RoundToNegativeInfinity(value));
}
else /* if (roundMode == RoundMode.TowardsZero) */
{
return(Sse41.RoundToZero(value));
}
}
public static decimal Round(this decimal d, int place, RoundMode mode)
{
decimal a = (10).Pow(place);
decimal[] addValues = { 0.9m, 0.5m, 0m };
decimal d1 = (d * a + addValues[(int)mode]).KillDecimal();
return d1.Divide(a);
}
public static float NearestMultipleOf(this float x, float multiple, RoundMode rm = RoundMode.UpDown)
{
float mod = x % multiple;
float midPoint = multiple / 2.0f;
if (rm == RoundMode.UpDown)
{
if (mod > midPoint)
{
return(x + (multiple - mod));
}
else
{
return(x - mod);
}
}
else if (rm == RoundMode.Up)
{
return(x + (multiple - mod));
}
else//(rm == RoundMode.Down)
{
return(x - mod);
}
}
public int TranslateToGrid(double value, RoundMode roundingMode)
{
var result = Translate(value);
switch (roundingMode)
{
case RoundMode.Round:
{
return((int)Math.Round(result));
}
case RoundMode.Ceiling:
{
return((int)Math.Ceiling(result));
}
case RoundMode.Floor:
{
return((int)Math.Floor(result));
}
case RoundMode.Truncate:
{
return((int)Math.Truncate(result));
}
}
throw new InvalidEnumArgumentException();
}
private void Awake()
{
RoundMode.roundMode = this;
isEndGame = false;
Time.timeScale = 1f;
Invoke("GetPlayerWithTeam", 0.5f);
LobbyButton.onClick.AddListener(OnClick_BackToLobby);
}
/// <summary>
/// Sets how image dimensions should be rounded to be power of two.
/// </summary>
/// <param name="inputOptions">Pointer to input options object.</param>
/// <param name="roundMode">Round mode enumeration.</param>
public void SetInputOptionsRoundMode(IntPtr inputOptions, RoundMode roundMode)
{
if (inputOptions == IntPtr.Zero)
{
return;
}
LoadIfNotLoaded();
Functions.nvttSetInputOptionsRoundMode func = GetFunction <Functions.nvttSetInputOptionsRoundMode>(FunctionNames.nvttSetInputOptionsRoundMode);
func(inputOptions, roundMode);
}
private static string GetVectorSse41NameRnd(RoundMode roundMode)
{
switch (roundMode)
{
case RoundMode.ToNearest:
return(nameof(Sse41.RoundToNearestInteger)); // even
case RoundMode.TowardsPlusInfinity:
return(nameof(Sse41.RoundToPositiveInfinity));
case RoundMode.TowardsMinusInfinity:
return(nameof(Sse41.RoundToNegativeInfinity));
default: /* case RoundMode.TowardsZero: */
return(nameof(Sse41.RoundToZero));
}
}
public void Reset()
{
ValueType v;
Freedom = Vector2.UnitX;
Projection = Vector2.UnitX;
DualProjection = Vector2.UnitX;
InstructionControl = InstructionControlFlags.None;
RoundState = RoundMode.ToGrid;
MinDistance = 1.0f;
ControlValueCutIn = 17.0f / 16.0f;
SingleWidthCutIn = 0.0f;
SingleWidthValue = 0.0f;
DeltaBase = 9;
DeltaShift = 3;
Loop = 1;
Rp0 = Rp1 = Rp2 = 0;
AutoFlip = true;
}
private static string GetSse41NameRnd(RoundMode roundMode)
{
switch (roundMode)
{
case RoundMode.ToNearest:
return(nameof(Sse41.RoundToNearestInteger)); // even
case RoundMode.TowardsMinusInfinity:
return(nameof(Sse41.RoundToNegativeInfinity));
case RoundMode.TowardsPlusInfinity:
return(nameof(Sse41.RoundToPositiveInfinity));
case RoundMode.TowardsZero:
return(nameof(Sse41.RoundToZero));
default: throw new ArgumentException(nameof(roundMode));
}
}
public void SetData(int decimals, string method)
{
_decimals = decimals;
if (method == "四捨五入")
{
_method = RoundMode.四捨五入;
}
else if (method == "無條件捨去")
{
_method = RoundMode.無條件捨去;
}
else if (method == "無條件進位")
{
_method = RoundMode.無條件進位;
}
else
{
_method = RoundMode.四捨五入;
}
}
public static float RoundF(float value, CpuThreadState state)
{
RoundMode roundMode = state.FPRoundingMode();
if (roundMode == RoundMode.ToNearest)
{
return(MathF.Round(value)); // even
}
else if (roundMode == RoundMode.TowardsPlusInfinity)
{
return(MathF.Ceiling(value));
}
else if (roundMode == RoundMode.TowardsMinusInfinity)
{
return(MathF.Floor(value));
}
else /* if (roundMode == RoundMode.TowardsZero) */
{
return(MathF.Truncate(value));
}
}
/// <summary>
/// run step 123.
/// </summary>
/// <returns></returns>
public override Expr Parse()
{
RoundMode mode = RoundMode.Round;
Token t = _tokenIt.Peek().Token;
if (string.Compare(t.Text, "up", StringComparison.InvariantCultureIgnoreCase) == 0)
{
mode = RoundMode.RoundUp;
_tokenIt.Advance();
}
else if (string.Compare(t.Text, "down", StringComparison.InvariantCultureIgnoreCase) == 0)
{
mode = RoundMode.RoundDown;
_tokenIt.Advance();
}
_tokenIt.Advance();
// The expression to round.
var exp = _parser.ParseExpression(null, true, true);
return(new RoundExpr(mode, exp));
}
private decimal GetRoundScore(decimal score, int decimals, RoundMode mode)
{
decimal seed = Convert.ToDecimal(Math.Pow(0.1, Convert.ToDouble(decimals)));
switch (mode)
{
default:
case RoundMode.四捨五入:
score = decimal.Round(score, decimals, MidpointRounding.AwayFromZero);
break;
case RoundMode.無條件捨去:
score /= seed;
score = decimal.Floor(score);
score *= seed;
break;
case RoundMode.無條件進位:
decimal d2 = GetRoundScore(score, decimals, RoundMode.無條件捨去);
if (d2 != score)
{
score = d2 + seed;
}
else
{
score = d2;
}
break;
}
string ss = "0.";
for (int i = 0; i < decimals; i++)
{
ss += "0";
}
return(Convert.ToDecimal(Math.Round(score, decimals).ToString(ss)));
}
/// <summary>
/// Rounds a float.
/// </summary>
/// <param name="x">The value to round.</param>
/// <param name="precision">The optional number of decimal digits to round to. Can be less than zero to ommit digits at the end. Default is <c>0</c>.</param>
/// <param name="mode">One of PHP_ROUND_HALF_UP, PHP_ROUND_HALF_DOWN, PHP_ROUND_HALF_EVEN, or PHP_ROUND_HALF_ODD. Default is <c>PHP_ROUND_HALF_UP</c>.</param>
/// <returns>The rounded value.</returns>
public static double round(double x, int precision = 0, RoundMode mode = RoundMode.HalfUp)
{
if (Double.IsInfinity(x) || Double.IsNaN(x) || x == default(double))
{
return(x);
}
if (precision == 0)
{
return(RoundInternal(x, mode));
}
else
{
if (precision > 23 || precision < -23)
{
return(x);
}
//
// Following code is taken from math.c to avoid incorrect .NET rounding
//
var precision_places = 14 - _Log10Abs(x);
var f1 = Power10Value(precision);
double tmp_value;
/* If the decimal precision guaranteed by FP arithmetic is higher than
* the requested places BUT is small enough to make sure a non-zero value
* is returned, pre-round the result to the precision */
if (precision_places > precision && precision_places - precision < 15)
{
var f2 = Power10Value(precision_places);
tmp_value = x * f2;
/* preround the result (tmp_value will always be something * 1e14,
* thus never larger than 1e15 here) */
tmp_value = RoundInternal(tmp_value, mode);
/* now correctly move the decimal point */
f2 = Power10Value(Math.Abs(precision - precision_places));
/* because places < precision_places */
tmp_value = tmp_value / f2;
}
else
{
/* adjust the value */
tmp_value = x * f1;
/* This value is beyond our precision, so rounding it is pointless */
if (Math.Abs(tmp_value) >= 1e15)
{
return(x);
}
}
/* round the temp value */
tmp_value = RoundInternal(tmp_value, mode);
/* see if it makes sense to use simple division to round the value */
//if (precision < 23 && precision > -23)
{
tmp_value = tmp_value / f1;
}
//else
//{
// /* Simple division can't be used since that will cause wrong results.
// Instead, the number is converted to a string and back again using
// strtod(). strtod() will return the nearest possible FP value for
// that string. */
// /* 40 Bytes should be more than enough for this format string. The
// float won't be larger than 1e15 anyway. But just in case, use
// snprintf() and make sure the buffer is zero-terminated */
// char buf[40];
// snprintf(buf, 39, "%15fe%d", tmp_value, -places);
// buf[39] = '\0';
// tmp_value = zend_strtod(buf, NULL);
// /* couldn't convert to string and back */
// if (!zend_finite(tmp_value) || zend_isnan(tmp_value)) {
// tmp_value = value;
// }
//}
return(tmp_value);
}
}
public void SetRoundMode(RoundMode mode)
{
nvttSetInputOptionsRoundMode(options, mode);
}
private static void EmitSse41Fcvt_Signed(ILEmitterCtx context, RoundMode roundMode, bool scalar)
{
OpCodeSimd64 op = (OpCodeSimd64)context.CurrOp;
// sizeF == ((OpCodeSimdShImm64)op).Size - 2
int sizeF = op.Size & 1;
if (sizeF == 0)
{
Type[] types = new Type[] { typeof(Vector128 <float>), typeof(Vector128 <float>) };
Type[] typesRndCvt = new Type[] { typeof(Vector128 <float>) };
Type[] typesSav = new Type[] { typeof(int) };
context.EmitLdvec(op.Rn);
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.CompareOrdered), types));
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.And), types));
if (op is OpCodeSimdShImm64 fixedOp)
{
int fBits = GetImmShr(fixedOp);
// BitConverter.Int32BitsToSingle(fpScaled) == MathF.Pow(2f, fBits)
int fpScaled = 0x3F800000 + fBits * 0x800000;
context.EmitLdc_I4(fpScaled);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.Multiply), types));
}
context.EmitCall(typeof(Sse41).GetMethod(GetVectorSse41NameRnd(roundMode), typesRndCvt));
context.EmitStvectmp();
context.EmitLdvectmp();
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.ConvertToVector128Int32), typesRndCvt));
context.EmitLdvectmp();
context.EmitLdc_I4(0x4F000000); // 2.14748365E9f (2147483648)
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqual), types));
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.Xor), types));
context.EmitStvec(op.Rd);
if (scalar)
{
EmitVectorZero32_128(context, op.Rd);
}
else if (op.RegisterSize == RegisterSize.Simd64)
{
EmitVectorZeroUpper(context, op.Rd);
}
}
else /* if (sizeF == 1) */
{
Type[] types = new Type[] { typeof(Vector128 <double>), typeof(Vector128 <double>) };
Type[] typesRndCvt = new Type[] { typeof(Vector128 <double>) };
Type[] typesSv = new Type[] { typeof(long), typeof(long) };
Type[] typesSav = new Type[] { typeof(long) };
context.EmitLdvec(op.Rn);
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.CompareOrdered), types));
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.And), types));
if (op is OpCodeSimdShImm64 fixedOp)
{
int fBits = GetImmShr(fixedOp);
// BitConverter.Int64BitsToDouble(fpScaled) == Math.Pow(2d, fBits)
long fpScaled = 0x3FF0000000000000L + fBits * 0x10000000000000L;
context.EmitLdc_I8(fpScaled);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.Multiply), types));
}
context.EmitCall(typeof(Sse41).GetMethod(GetVectorSse41NameRnd(roundMode), typesRndCvt));
context.EmitStvectmp();
if (!scalar)
{
context.EmitLdvectmp();
context.EmitLdvectmp();
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.UnpackHigh), types));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.ConvertToInt64), typesRndCvt));
}
else
{
context.EmitLdc_I8(0L);
}
context.EmitLdvectmp();
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.ConvertToInt64), typesRndCvt));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetVector128), typesSv));
context.EmitLdvectmp();
context.EmitLdc_I8(0x43E0000000000000L); // 9.2233720368547760E18d (9223372036854775808)
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqual), types));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.Xor), types));
context.EmitStvec(op.Rd);
if (scalar)
{
EmitVectorZeroUpper(context, op.Rd);
}
}
}
private static void EmitSse41Fcvt_Signed_Gp(ILEmitterCtx context, RoundMode roundMode, bool isFixed)
{
OpCodeSimdCvt64 op = (OpCodeSimdCvt64)context.CurrOp;
if (op.Size == 0)
{
Type[] typesCmpMul = new Type[] { typeof(Vector128 <float>), typeof(Vector128 <float>) };
Type[] typesAnd = new Type[] { typeof(Vector128 <long>), typeof(Vector128 <long>) };
Type[] typesRndCvt = new Type[] { typeof(Vector128 <float>) };
Type[] typesCvt = new Type[] { typeof(Vector128 <int>) };
Type[] typesSav = new Type[] { typeof(int) };
//string nameCvt;
int fpMaxVal;
if (op.RegisterSize == RegisterSize.Int32)
{
//nameCvt = nameof(Sse.ConvertToInt32);
fpMaxVal = 0x4F000000; // 2.14748365E9f (2147483648)
}
else
{
//nameCvt = nameof(Sse.ConvertToInt64);
fpMaxVal = 0x5F000000; // 9.223372E18f (9223372036854775808)
}
context.EmitLdvec(op.Rn);
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.CompareOrdered), typesCmpMul));
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.And), typesAnd));
if (isFixed)
{
// BitConverter.Int32BitsToSingle(fpScaled) == MathF.Pow(2f, op.FBits)
int fpScaled = 0x40000000 + (op.FBits - 1) * 0x800000;
context.EmitLdc_I4(fpScaled);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.Multiply), typesCmpMul));
}
context.EmitCall(typeof(Sse41).GetMethod(GetSse41NameRnd(roundMode), typesRndCvt));
context.EmitStvectmp();
context.EmitLdvectmp();
// TODO: Use Sse.ConvertToInt64 once it is fixed (in .NET Core 3.0),
// remove the following if/else and uncomment the code.
//context.EmitCall(typeof(Sse).GetMethod(nameCvt, typesRndCvt));
if (op.RegisterSize == RegisterSize.Int32)
{
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.ConvertToInt32), typesRndCvt));
}
else
{
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.ConvertToVector128Double), typesRndCvt));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.ConvertToInt64), new Type[] { typeof(Vector128 <double>) }));
}
context.EmitLdvectmp();
context.EmitLdc_I4(fpMaxVal);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqual), typesCmpMul));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.ConvertToInt32), typesCvt));
if (op.RegisterSize == RegisterSize.Int32)
{
context.Emit(OpCodes.Xor);
context.Emit(OpCodes.Conv_U8);
}
else
{
context.Emit(OpCodes.Conv_I8);
context.Emit(OpCodes.Xor);
}
context.EmitStintzr(op.Rd);
}
else /* if (op.Size == 1) */
{
Type[] typesCmpMul = new Type[] { typeof(Vector128 <double>), typeof(Vector128 <double>) };
Type[] typesAnd = new Type[] { typeof(Vector128 <long>), typeof(Vector128 <long>) };
Type[] typesRndCvt = new Type[] { typeof(Vector128 <double>) };
Type[] typesCvt = new Type[] { typeof(Vector128 <int>) };
Type[] typesSav = new Type[] { typeof(long) };
string nameCvt;
long fpMaxVal;
if (op.RegisterSize == RegisterSize.Int32)
{
nameCvt = nameof(Sse2.ConvertToInt32);
fpMaxVal = 0x41E0000000000000L; // 2147483648.0000000d (2147483648)
}
else
{
nameCvt = nameof(Sse2.ConvertToInt64);
fpMaxVal = 0x43E0000000000000L; // 9.2233720368547760E18d (9223372036854775808)
}
context.EmitLdvec(op.Rn);
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.CompareOrdered), typesCmpMul));
context.EmitLdvec(op.Rn);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.And), typesAnd));
if (isFixed)
{
// BitConverter.Int64BitsToDouble(fpScaled) == Math.Pow(2d, op.FBits)
long fpScaled = 0x4000000000000000L + (op.FBits - 1) * 0x10000000000000L;
context.EmitLdc_I8(fpScaled);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.Multiply), typesCmpMul));
}
context.EmitCall(typeof(Sse41).GetMethod(GetSse41NameRnd(roundMode), typesRndCvt));
context.EmitStvectmp();
context.EmitLdvectmp();
context.EmitCall(typeof(Sse2).GetMethod(nameCvt, typesRndCvt));
context.EmitLdvectmp();
context.EmitLdc_I8(fpMaxVal);
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), typesSav));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqual), typesCmpMul));
context.EmitCall(typeof(Sse2).GetMethod(nameof(Sse2.ConvertToInt32), typesCvt));
if (op.RegisterSize == RegisterSize.Int32)
{
context.Emit(OpCodes.Xor);
context.Emit(OpCodes.Conv_U8);
}
else
{
context.Emit(OpCodes.Conv_I8);
context.Emit(OpCodes.Xor);
}
context.EmitStintzr(op.Rd);
}
}
private static double RoundInternal(double value, RoundMode mode)
{
double tmp_value;
if (value >= 0.0)
{
tmp_value = Math.Floor(value + 0.5);
if (mode != RoundMode.HalfUp)
{
if ((mode == RoundMode.HalfDown && value == (-0.5 + tmp_value)) ||
(mode == RoundMode.HalfEven && value == (0.5 + 2 * Math.Floor(tmp_value * .5))) ||
(mode == RoundMode.HalfOdd && value == (0.5 + 2 * Math.Floor(tmp_value * .5) - 1.0)))
{
tmp_value = tmp_value - 1.0;
}
}
}
else
{
tmp_value = Math.Ceiling(value - 0.5);
if (mode != RoundMode.HalfUp)
{
if ((mode == RoundMode.HalfDown && value == (0.5 + tmp_value)) ||
(mode == RoundMode.HalfEven && value == (-0.5 + 2 * Math.Ceiling(tmp_value * .5))) ||
(mode == RoundMode.HalfOdd && value == (-0.5 + 2 * Math.Ceiling(tmp_value * .5) + 1.0)))
{
tmp_value = tmp_value + 1.0;
}
}
}
return tmp_value;
}
public static int round(double x, int precision, RoundMode mode = RoundMode.Up)
{
throw new NotImplementedException();
return((int)Math.Round(x));
}
public void Reset()
{
Freedom = Vector2.UnitX;
Projection = Vector2.UnitX;
DualProjection = Vector2.UnitX;
InstructionControl = InstructionControlFlags.None;
RoundState = RoundMode.ToGrid;
MinDistance = 1.0f;
ControlValueCutIn = 17.0f / 16.0f;
SingleWidthCutIn = 0.0f;
SingleWidthValue = 0.0f;
DeltaBase = 9;
DeltaShift = 3;
Loop = 1;
Rp0 = Rp1 = Rp2 = 0;
AutoFlip = true;
}
public static int NearestMultipleOf(this int x, int multiple, RoundMode rm = RoundMode.UpDown)
{
return(Mathf.RoundToInt(((float)x).NearestMultipleOf((float)multiple, rm)));
}
public static double Round(double x, int precision /*= 0*/, RoundMode mode /*= RoundMode.HalfUp*/)
{
if (Double.IsInfinity(x) || Double.IsNaN(x) || x == default(double))
return x;
if (precision == 0)
{
return RoundInternal(x, mode);
}
else
{
if (precision > 23 || precision < -23)
return x;
//
// Following code is taken from math.c to avoid incorrect .NET rounding
//
var precision_places = 14 - _Log10Abs(x);
var f1 = Power10Value(precision);
double tmp_value;
/* If the decimal precision guaranteed by FP arithmetic is higher than
the requested places BUT is small enough to make sure a non-zero value
is returned, pre-round the result to the precision */
if (precision_places > precision && precision_places - precision < 15)
{
var f2 = Power10Value(precision_places);
tmp_value = x * f2;
/* preround the result (tmp_value will always be something * 1e14,
thus never larger than 1e15 here) */
tmp_value = RoundInternal(tmp_value, mode);
/* now correctly move the decimal point */
f2 = Power10Value(Math.Abs(precision - precision_places));
/* because places < precision_places */
tmp_value = tmp_value / f2;
}
else
{
/* adjust the value */
tmp_value = x * f1;
/* This value is beyond our precision, so rounding it is pointless */
if (Math.Abs(tmp_value) >= 1e15)
return x;
}
/* round the temp value */
tmp_value = RoundInternal(tmp_value, mode);
/* see if it makes sense to use simple division to round the value */
//if (precision < 23 && precision > -23)
{
tmp_value = tmp_value / f1;
}
//else
//{
// /* Simple division can't be used since that will cause wrong results.
// Instead, the number is converted to a string and back again using
// strtod(). strtod() will return the nearest possible FP value for
// that string. */
// /* 40 Bytes should be more than enough for this format string. The
// float won't be larger than 1e15 anyway. But just in case, use
// snprintf() and make sure the buffer is zero-terminated */
// char buf[40];
// snprintf(buf, 39, "%15fe%d", tmp_value, -places);
// buf[39] = '\0';
// tmp_value = zend_strtod(buf, NULL);
// /* couldn't convert to string and back */
// if (!zend_finite(tmp_value) || zend_isnan(tmp_value)) {
// tmp_value = value;
// }
//}
return tmp_value;
}
}
public OperatingRound(GameState gameState, Company activeCompany, int roundNumber, RoundMode mode)
: base(activeCompany)
{
RoundNumber = roundNumber;
RoundMode = mode;
}
private extern static void nvttSetInputOptionsRoundMode(IntPtr inputOptions, RoundMode mode);
/// <summary>
/// Round specified DateTime value to nearest whole value in specified interval.
/// In example, origin = 2014-03-20 14:56:21, round = FromMinutes(15), mode = Floor; result = 2014-03-20 14:45:00
/// </summary>
/// <param name="origin">Original DateTime</param>
/// <param name="round">Round divisor (amount of time, to which will be original DateTime rounded)</param>
/// <param name="mode">Round mode</param>
/// <returns>Rounded DateTime</returns>
public static DateTime RoundDateTime(DateTime origin, TimeSpan round, RoundMode mode)
{
DateTime result = origin;
double rDays = round.TotalDays;
if (round.Ticks <= 0L)
{ // No round:
result = origin;
}
else if (rDays < 1D)
{ // Round time (hour:min:sec):
double seconds = origin.TimeOfDay.TotalSeconds; // Time in seconds (i.e. 17.9.2008 16:25:40 = 59140)
seconds = _RoundToDivisor(seconds, round.TotalSeconds, mode); // Round seconds to divisor, i.e. 15 min = 900 sec: 59140 => 59400 = 16:30:00
result = origin.Date.AddSeconds(seconds); // Rounded time = Date (without Time) + rounded seconds, i.e. 17.9.2008 + 59400 sec = 16:30:00
}
else if (rDays < 7D)
{ // Round date to days:
double day = origin.TimeOfDay.TotalDays; // Time as day fragment (time 18:00 = 18/24 = 0.75d)
day = _RoundToDivisor(day, 1d, mode); // Round day fragment (TimeOfDay) to 0 or 1, by mode
result = origin.Date.AddDays(day);
}
else if (rDays <= 14D)
{ // Round date to week (to Monday):
DateTime monday = _GetMonday(origin); // Nearest lower (or equal) Monday to origin DateTime
double dow = ((TimeSpan)(origin - monday)).TotalDays; // Day in week as number: Monday 00:00 = 0.00; Sunday 00:00 = 6.00; Sunday 18:00 = 6.75d, and so on... (count of whole day + time in day, beginning Monday, 00:00)
dow = _RoundToDivisor(dow, 7d, mode); // Value 0.0d or 7.0d
result = monday.Date.AddDays(dow);
}
else if (rDays <= 31d)
{ // Round date to first day of Month:
DateTime first = new DateTime(origin.Year, origin.Month, 1); // First day of specified year and month
double day = ((TimeSpan)(origin - first)).TotalDays; // Current day (and time) in month, as number
double count = ((TimeSpan)(first.AddMonths(1) - first)).TotalDays; // Count of day in specified month
day = _RoundToDivisor(day, count, mode); // Value 0.0d or (count)
result = (day == 0d ? first : first.AddMonths(1));
}
else if (rDays <= 92d)
{ // Round date to first day of Quartale:
int month = origin.Month;
month = ((month - 1) / 3) * 3 + 1;
DateTime first = new DateTime(origin.Year, month, 1); // First day of specified year and quartale month
double day = ((TimeSpan)(origin - first)).TotalDays; // Current day (and time) in quartale, as number
double count = ((TimeSpan)(first.AddMonths(3) - first)).TotalDays; // Count of day in specified quartale
day = _RoundToDivisor(day, count, mode); // Value 0.0d or (count)
result = (day == 0d ? first : first.AddMonths(3));
}
else if (rDays <= 182d)
{ // Round date to 1.1. or to 1.7. (half-year):
int month = origin.Month;
month = ((month - 1) / 6) * 6 + 1;
DateTime first = new DateTime(origin.Year, month, 1); // First day of specified year and half-year month
double day = ((TimeSpan)(origin - first)).TotalDays; // Current day (and time) in half-year, as number
double count = ((TimeSpan)(first.AddMonths(6) - first)).TotalDays; // Count of day in specified half-year
day = _RoundToDivisor(day, count, mode); // Value 0.0d or (count)
result = (day == 0d ? first : first.AddMonths(6));
}
else if (rDays <= 366d)
{ // Round date to first day of Year:
DateTime first = new DateTime(origin.Year, 1, 1); // First day of specified year
double day = ((TimeSpan)(origin - first)).TotalDays; // Current day (and time) in month, as number
double count = ((TimeSpan)(first.AddYears(1) - first)).TotalDays; // Count of day in specified year
day = _RoundToDivisor(day, count, mode); // Value 0.0d or (count)
result = (day == 0d ? first : first.AddYears(1));
}
else
{ // Round date to first day of n-th Years:
DateTime first = new DateTime(origin.Year, 1, 1); // First day of specified year
double day = ((TimeSpan)(origin - first)).TotalDays; // Current day (and time) in month, as number
double count = ((TimeSpan)(first.AddYears(1) - first)).TotalDays; // Count of day in specified year
day = _RoundToDivisor(day, count, mode); // Value 0.0d or (count)
result = (day == 0d ? first : first.AddYears(1));
}
return(result);
}
public Round()
{
_decimals = 2;
_method = RoundMode.四捨五入;
}
public MergerRound(Company activeCompany, int roundNumber, RoundMode mode)
: base(activeCompany)
{
RoundNumber = roundNumber;
RoundMode = mode;
}
public static GridUnitsTranslator GetUnitsTranslator(GridUnit sourceUnit, GridUnit targetUnit, RoundMode roundMode = RoundMode.Round)
{
return(new GridUnitsTranslator(sourceUnit, targetUnit, roundMode));
}
public void SetRoundMode(RoundMode mode)
{
nvttSetInputOptionsRoundMode(options, mode);
}
public GridUnitsTranslator(GridUnit sourceUnit, GridUnit targetUnit, RoundMode roundMode = RoundMode.Round)
{
this.roundMode = roundMode;
multiplier = (double)targetUnit.Divisor / sourceUnit.Divisor;
}
private static extern void nvttSetInputOptionsRoundMode(IntPtr inputOptions, RoundMode mode);
/// <summary>
/// Returns specified value (value on axis, TTick: for example DateTime) rounded to an interval (TSize: for example TimeSpan) with RoundMode.
/// For example on TimeAxis: when value is 15.2.2016 14:35:16.165; and interval is 00:15:00.000, then result RoundValue is 15.2.2016 14:30:00 (for RoundMode = Math).
/// </summary>
/// <param name="value">Value (Tick) for round</param>
/// <param name="interval">Interval on which will be Tick rounded</param>
/// <param name="roundMode">Mode for round</param>
/// <returns></returns>
protected override decimal?RoundTickToInterval(decimal?value, decimal?interval, RoundMode roundMode)
{
return(value.HasValue && interval.HasValue ? (decimal?)DecimalNRange.RoundValue(value.Value, interval.Value, roundMode) : (decimal?)null);
}
