public RPICameraClient(TcpVideoClient clientInstance)
{
InitializeComponent();
_compressionRate = 0;
_videoClient = clientInstance;
FormClosing += FormClosingEvent;
}
public static BitCoin TakePercent(this BitCoin b, Percent p)
{
decimal onePercentInSatoshi = (b.SatoshiAmount / 100m);
var totalSatoshi = onePercentInSatoshi * p.Value;
return(BitCoin.FromSatoshi((ulong)Math.Floor(totalSatoshi)));
}
public void PercentToPercentAdditionAndSubtractionShouldWork()
{
var percent1 = Percent.Hundred;
var percent2 = Percent.Fifty;
(percent1 - percent2).Should().Be(Percent.Fifty);
(percent1 + percent2).Should().Be(Percent.From(150));
}
internal void MoveTo(Transform moveWhat, Vector3 @where, Action onFinish, Percent speed)
{
this.speed = speed;
this.onFinish = onFinish;
this.moveWhat = moveWhat;
this.start = moveWhat.transform.position;
this.end = @where;
this.distance = (end - start).magnitude;
}
public StateOfChargeMessage(byte[] payload)
{
payload.RequireBytes(RequireBytes);
StateOfChargeUI = new Percent(BitArrayConverter.ToUInt16(payload, 0, 10) * 0.1m);
StateOfChargeMin = new Percent(BitArrayConverter.ToUInt16(payload, 10, 10) * 0.1m);
StateOfChargeMax = new Percent(BitArrayConverter.ToUInt16(payload, 20, 10) * 0.1m);
StateOfChargeAvg = new Percent(BitArrayConverter.ToUInt16(payload, 30, 10) * 0.1m);
}
bool Finalize()
{
_timer = null;
Time.Next(1f);
Percent.Next(100);
return(true);
}
public void Calculate()
{
BaseTotal = BudgetItems.Sum(bi => bi.BaseAmount);
foreach (BudgetItem item in BudgetItems)
{
item.Percent = Percent.Value(item.BaseAmount, BaseTotal);
}
}
public void CalculateMethodShouldReturnExpectedResults()
{
Percent.CalculatePercentAmountFromValue(TestInt, Percent.Ten).Should().Be(TenPercentTestInt);
Percent.CalculatePercentAmountFromValue(TestNegativeInt, Percent.Ten).Should().Be(-TenPercentTestInt);
Percent.CalculatePercentAmountFromValue(TestLong, Percent.Ten).Should().Be(TenPercentTestInt);
Percent.CalculatePercentAmountFromValue(TestNegativeLong, Percent.Ten).Should().Be(-TenPercentTestInt);
Percent.CalculatePercentAmountFromValue(TestDecimal, Percent.Ten).Should().Be(TenPercentTestDecimal);
Percent.CalculatePercentAmountFromValue(TestNegativeDecimal, Percent.Ten).Should().Be(-TenPercentTestDecimal);
}
public StateOfChargeMessage(byte[] payload)
{
payload.RequireBytes(RequireBytes);
DetermineChargeTotalType(payload);
ChargeTotal = new KiloWattHour((payload[4] + (payload[5] << 8) + (payload[6] << 16) + (payload[7] << 24)) / 1000.0m);
StateOfChargeMin = new Percent((payload[0] + ((payload[1] & 0x3) << 8)) / 10m);
StateOfChargeDisplayed = new Percent((payload[1] >> 2) + ((payload[2] & 0xF) << 6) / 10.0m);
}
private static string ToString(Percent percent)
{
var p = (decimal)percent;
var fractional = p - Math.Truncate(p);
return(fractional == decimal.Zero
? p.ToString("N0", CultureInfo.CurrentCulture)
: p.ToString("N2", CultureInfo.CurrentCulture));
}
public bool TryConvert(object from, Type toType, object conversionHint, out object result)
{
if (toType == typeof(double))
{
if (from is Percent p)
{
result = p.Value;
return(true);
}
result = 0d;
return(false);
}
if (toType == typeof(double?))
{
if (from is Percent p)
{
result = p.Value;
return(true);
}
if (from == null)
{
result = default(double?);
return(true);
}
result = default(double?);
return(false);
}
if (toType == typeof(Percent))
{
if (from is double d)
{
result = Percent.FactoryPutInRange(d);
return(true);
}
result = Percent.Zero;
return(false);
}
if (toType == typeof(Percent?))
{
if (from is double d)
{
result = Percent.FactoryPutInRange(d);
return(true);
}
if (from == null)
{
result = default(Percent?);
return(true);
}
result = Percent.Zero;
return(false);
}
result = null;
return(false);
}
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
string percentStr = value?.ToString();
if (percentStr == null)
{
throw new ArgumentException("Unable to parse 'null' as percent");
}
return(Percent.Parse(percentStr, CultureInfo.CurrentCulture));
}
internal decimal CalculateAdministrativeFee(
decimal loanAmount,
Percent administrativeFeeRate,
Money administrativeFeeMaxCap
)
{
var feeFromPercentRate = loanAmount * administrativeFeeRate.ToFraction();
return(Math.Min(feeFromPercentRate, administrativeFeeMaxCap.Amount));
}
public static bool IsRandomChanceOccured(Percent chance)
{
if (chance == Percent.Zero)
{
return(false);
}
var randomValue = GetNextIncludingMax(1, 100);
return(randomValue <= chance.Value);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Item?.GetHashCode() ?? 0;
hashCode = (hashCode * 397) ^ Percent.GetHashCode();
hashCode = (hashCode * 397) ^ (Value?.GetHashCode() ?? 0);
return(hashCode);
}
}
public ActionResult Edit([Bind(Include = "PercentID,Beginner,Intermediate,Expert")] Percent percent)
{
if (ModelState.IsValid)
{
db.Entry(percent).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(percent));
}
public double Execute_WhenAnyValues_ThenReturnPercent(double value1, double value2)
{
//Arrange
var percent = new Percent();
//Act
var result = percent.Execute(value1, value2);
//Assert
return(result);
}
public ActionResult Create([Bind(Include = "PercentID,Beginner,Intermediate,Expert")] Percent percent)
{
if (ModelState.IsValid)
{
db.Percents.Add(percent);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(percent));
}
public void GetExecutableInfo_WhenAnyValues_ThenCanExecute(double value1, double value2)
{
//Arrange
var percent = new Percent();
//Act
var executableInfo = percent.GetExecutableInfo(value1, value2);
//Assert
Assert.That(executableInfo.CanBeExecuted, Is.True);
}
public int CompareTo(ShipSupply obj)
{
if (obj == null)
{
return(1);
}
else
{
return(Percent.CompareTo(obj.Percent));
}
}
public NPC SpawnNPC(GridSpace g, Percent variety, params SpawnKeywords[] keywords)
{
if (Probability.SpawnRand.Percent(variety))
{
return(SpawnNPC(g));
}
else
{
return(SpawnNPC(g, keywords));
}
}
protected void CalculateDiscount(double discountPercent)
{
discountPercent = Math.Min(discountPercent, 99);
discountPercent = Math.Max(discountPercent, -99);
discountPercent = Percent.Round(discountPercent);
Discount = discountPercent;
CalculateDiscountValue();
PriceEvaluate();
TotalEvaluate();
}
public void SetProgComplete(int percentage)
{
int Width = (int)Math.Floor((double)((this.ClientRectangle.Width * percentage) / 100));
int Height = (int)this.ClientRectangle.Height;
if (Width > 0 && Height > 0)
{
this.Invalidate(new Rectangle(this.ClientRectangle.X, this.ClientRectangle.Y, Width, Height));
lblGrdPrgBar.Text = Percent.ToString() + "%";
}
}
public void SetPercentageDiscount(Percent percentOff)
{
var itemPercentageDiscountSetEvent = new ItemPercentageDiscountSetEvent
{
Id = Id,
Version = CurrentVersion + 1,
PercentOff = percentOff
};
Apply(itemPercentageDiscountSetEvent, isNew: true);
}
public void downloaded(Percent percentage_complete)
{
shell.region<ToolStripProgressBar>(
x =>
{
while (percentage_complete.is_less_than(x.Value))
{
if (percentage_complete.represents(x.Value)) break;
x.PerformStep();
}
});
}
/// <summary>
/// Creates a projection that returns the percentage of the viewport time aggregation is consumed by this
/// <see cref="double"/>.
/// </summary>
/// <param name="percentColumn">
/// Percentage projection returning a double.
/// </param>
/// <returns>
/// Percent of value consumed by delta in the given viewport projection.
/// </returns>
public static IProjection <int, double> Create(IProjection <int, double> percentColumn)
{
Guard.NotNull(percentColumn, nameof(percentColumn));
var percentColumnAggregate
= Projection.AggregateInViewport <double, double>(percentColumn);
var columnRelativeToViewport
= Percent.Create(percentColumn, percentColumnAggregate);
return(columnRelativeToViewport);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (Name != null ? Name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Pollutant != null ? Pollutant.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ Limit.GetHashCode();
hashCode = (hashCode * 397) ^ Percent.GetHashCode();
hashCode = (hashCode * 397) ^ Id;
return(hashCode);
}
}
bool Update(float dt)
{
if (null != _delay)
{
if (!_delay.UpdateTimer(dt))
{
_delay = null;
OnStart?.Invoke();
}
// return false when delaying so that OnLerp in InterpolationBase below wont get called on Run()
return(false);
}
if (null != _timer && !_timer.UpdateTimer(dt))
{
// if it needs to repeat...
if (_timing.repeat > 0)
{
++_counter;
if (_counter <= _timing.repeat)
{
_timer.Reset();
}
else
{
return(Finalize());
}
}
else if (_timing.repeat < 0)
{
// restart if it needs to repeat forever
Start();
}
else
{
// if it doesnt need to repeat, set done immediately
return(Finalize());
}
}
// update observables
if (null != _timer)
{
float t = CEasings.GetEasing(_timer.GetPercentage(), _timing.easing);
Time.Next(t);
Percent.Next((int)(Time.Value * 100f));
}
return(_timer != null);
}
public override LoanEntity ToEntity()
{
Percent = Percent.Replace("%", string.Empty);
var result = new LoanEntity();
result.LoanAmount = decimal.Parse(LoanAmount, CultureInfo.InvariantCulture);
result.Percent = decimal.Parse(Percent, CultureInfo.InvariantCulture);
result.DownPaymentAmount = decimal.Parse(DownPaymentAmount, CultureInfo.InvariantCulture);
result.TermInYears = int.Parse(TermInYears);
return(result);
}
/// <summary>
/// Creates a projection that returns the percentage of the viewport time aggregation consumed by this
/// <see cref="TimestampDelta"/>.
/// </summary>
/// <param name="timestampDeltaColumn">
/// Timestamp delta.
/// </param>
/// <returns>
/// Percent of time consumed by delta in the given viewport projection.
/// </returns>
public static IProjection <int, double> Create(
IProjection <int, TimestampDelta> timestampDeltaColumn)
{
Guard.NotNull(timestampDeltaColumn, nameof(timestampDeltaColumn));
var aggregateRowsInViewportColumn
= Projection.AggregateInViewport <TimestampDelta, TimestampDelta>(timestampDeltaColumn);
var columnRelativeToViewport
= Percent.Create(timestampDeltaColumn, aggregateRowsInViewportColumn);
return(columnRelativeToViewport);
}
Percent GetPercent(string str)
{
Percent obj = null;
if (!string.IsNullOrEmpty(str))
{
obj = new Percent();
var strs = str.Split(':');
obj.baseValue = float.Parse(strs[0]);
obj.maxValue = float.Parse(strs[1]);
}
return(obj);
}
public void CanLoadArmor()
{
// Vampire armor of destruction
var armr = new Armor(new Cursor((RelativePath)"Dawnguard.esm", 0x02015CBA));
Assert.Equal("<EDID - DLC1EnchClothesVampireRobesDestruction02>", armr.EditorId.Value.ToString());
Assert.Equal("Vampire Armor of Destruction", armr.FullName.Value);
Assert.Equal(Percent.FactoryPutInRange(0.25), armr.ArmorRating.Value);
Assert.Equal("Vampire Armor", armr.TemplateArmor.Value.FullName.Value);
Assert.Equal("Fortify Destruction", armr.Enchantment.Value.FullName.Value);
}
private ChargeStatus __TMPGetStatus(object localId) {
var id = (string)localId;
var state = PowerState.Charging;
var p = new Percent(DateTime.Now.Minute / 60d);
return new ChargeStatus {
ChargingPower = new Power(16),
IsClimateControlOn = _TMPr.NextDouble() < .5,
PlannedDuration = state == PowerState.Charging ? TimeSpan.FromHours(6 * p) : TimeSpan.Zero,
Soc = p,
State = state,
};
}
private void slider1_ValueChanged(object sender, EventArgs e)
{
_compressionRate = slider1.Value;
}
/**
* Parses the sublist of tokens. In most cases this will equate to
* the full list
*
* @param len the length of the subexpression to parse
* @exception FormulaException
*/
private void parseSubExpression(int len)
{
int tokenVal = 0;
Token t = null;
// Indicates that we are parsing the incredibly complicated and
// hacky if construct that MS saw fit to include, the gits
Stack<ParseItem> ifStack = new Stack<ParseItem>();
// The end position of the sub-expression
int endpos = pos + len;
while (pos < endpos)
{
tokenVal = tokenData[pos];
pos++;
t = Token.getToken(tokenVal);
if (t == Token.UNKNOWN)
{
throw new FormulaException
(FormulaException.UNRECOGNIZED_TOKEN,tokenVal);
}
Assert.verify(t != Token.UNKNOWN);
// Operands
if (t == Token.REF)
{
CellReference cr = new CellReference(relativeTo);
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.REFERR)
{
CellReferenceError cr = new CellReferenceError();
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.ERR)
{
ErrorConstant ec = new ErrorConstant();
pos += ec.read(tokenData,pos);
tokenStack.Push(ec);
}
else if (t == Token.REFV)
{
SharedFormulaCellReference cr =
new SharedFormulaCellReference(relativeTo);
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.REF3D)
{
CellReference3d cr = new CellReference3d(relativeTo,workbook);
pos += cr.read(tokenData,pos);
tokenStack.Push(cr);
}
else if (t == Token.AREA)
{
Area a = new Area();
pos += a.read(tokenData,pos);
tokenStack.Push(a);
}
else if (t == Token.AREAV)
{
SharedFormulaArea a = new SharedFormulaArea(relativeTo);
pos += a.read(tokenData,pos);
tokenStack.Push(a);
}
else if (t == Token.AREA3D)
{
Area3d a = new Area3d(workbook);
pos += a.read(tokenData,pos);
tokenStack.Push(a);
}
else if (t == Token.NAME)
{
Name n = new Name();
pos += n.read(tokenData,pos);
n.setParseContext(parseContext);
tokenStack.Push(n);
}
else if (t == Token.NAMED_RANGE)
{
NameRange nr = new NameRange(nameTable);
pos += nr.read(tokenData,pos);
nr.setParseContext(parseContext);
tokenStack.Push(nr);
}
else if (t == Token.INTEGER)
{
IntegerValue i = new IntegerValue();
pos += i.read(tokenData,pos);
tokenStack.Push(i);
}
else if (t == Token.DOUBLE)
{
DoubleValue d = new DoubleValue();
pos += d.read(tokenData,pos);
tokenStack.Push(d);
}
else if (t == Token.BOOL)
{
BooleanValue bv = new BooleanValue();
pos += bv.read(tokenData,pos);
tokenStack.Push(bv);
}
else if (t == Token.STRING)
{
StringValue sv = new StringValue(settings);
pos += sv.read(tokenData,pos);
tokenStack.Push(sv);
}
else if (t == Token.MISSING_ARG)
{
MissingArg ma = new MissingArg();
pos += ma.read(tokenData,pos);
tokenStack.Push(ma);
}
// Unary Operators
else if (t == Token.UNARY_PLUS)
{
UnaryPlus up = new UnaryPlus();
pos += up.read(tokenData,pos);
addOperator(up);
}
else if (t == Token.UNARY_MINUS)
{
UnaryMinus um = new UnaryMinus();
pos += um.read(tokenData,pos);
addOperator(um);
}
else if (t == Token.PERCENT)
{
Percent p = new Percent();
pos += p.read(tokenData,pos);
addOperator(p);
}
// Binary Operators
else if (t == Token.SUBTRACT)
{
Subtract s = new Subtract();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.ADD)
{
Add s = new Add();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.MULTIPLY)
{
Multiply s = new Multiply();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.DIVIDE)
{
Divide s = new Divide();
pos += s.read(tokenData,pos);
addOperator(s);
}
else if (t == Token.CONCAT)
{
Concatenate c = new Concatenate();
pos += c.read(tokenData,pos);
addOperator(c);
}
else if (t == Token.POWER)
{
Power p = new Power();
pos += p.read(tokenData,pos);
addOperator(p);
}
else if (t == Token.LESS_THAN)
{
LessThan lt = new LessThan();
pos += lt.read(tokenData,pos);
addOperator(lt);
}
else if (t == Token.LESS_EQUAL)
{
LessEqual lte = new LessEqual();
pos += lte.read(tokenData,pos);
addOperator(lte);
}
else if (t == Token.GREATER_THAN)
{
GreaterThan gt = new GreaterThan();
pos += gt.read(tokenData,pos);
addOperator(gt);
}
else if (t == Token.GREATER_EQUAL)
{
GreaterEqual gte = new GreaterEqual();
pos += gte.read(tokenData,pos);
addOperator(gte);
}
else if (t == Token.NOT_EQUAL)
{
NotEqual ne = new NotEqual();
pos += ne.read(tokenData,pos);
addOperator(ne);
}
else if (t == Token.EQUAL)
{
Equal e = new Equal();
pos += e.read(tokenData,pos);
addOperator(e);
}
else if (t == Token.PARENTHESIS)
{
Parenthesis p = new Parenthesis();
pos += p.read(tokenData,pos);
addOperator(p);
}
// Functions
else if (t == Token.ATTRIBUTE)
{
Attribute a = new Attribute(settings);
pos += a.read(tokenData,pos);
if (a.isSum())
addOperator(a);
else if (a.isIf())
{
// Add it to a special stack for ifs
ifStack.Push(a);
}
}
else if (t == Token.FUNCTION)
{
BuiltInFunction bif = new BuiltInFunction(settings);
pos += bif.read(tokenData,pos);
addOperator(bif);
}
else if (t == Token.FUNCTIONVARARG)
{
VariableArgFunction vaf = new VariableArgFunction(settings);
pos += vaf.read(tokenData,pos);
if (vaf.getFunction() != Function.ATTRIBUTE)
addOperator(vaf);
else
{
// This is part of an IF function. Get the operands, but then
// add it to the top of the if stack
vaf.getOperands(tokenStack);
Attribute ifattr = null;
if (ifStack.Count == 0)
ifattr = new Attribute(settings);
else
ifattr = (Attribute)ifStack.Pop();
ifattr.setIfConditions(vaf);
tokenStack.Push(ifattr);
}
}
// Other things
else if (t == Token.MEM_FUNC)
{
MemFunc memFunc = new MemFunc();
handleMemoryFunction(memFunc);
}
else if (t == Token.MEM_AREA)
{
MemArea memArea = new MemArea();
handleMemoryFunction(memArea);
}
}
}
