public override INode AddOrUpdate(OneItemLeaf item)
{
if (item.Hash < LeftItem.Hash)
{
var newLeft = Left.AddOrUpdate(item);
return(!IsEmerged(newLeft, Left)
? new TwoItemsTree(LeftItem, RightItem, newLeft, Middle, Right)
: (INode) new OneItemTree(LeftItem, newLeft, new OneItemTree(RightItem, Middle, Right)));
}
// if (item.Hash == LeftItem.Hash)
if (item.Hash < RightItem.Hash)
{
var newMiddle = Middle.AddOrUpdate(item);
if (!IsEmerged(newMiddle, Middle))
{
return(new TwoItemsTree(LeftItem, RightItem, Left, newMiddle, Right));
}
var emergedMiddle = (OneItemTree)newMiddle;
return(new OneItemTree(emergedMiddle.Item,
new OneItemTree(LeftItem, Left, emergedMiddle.Right),
new OneItemTree(RightItem, emergedMiddle.Left, Right)));
}
// for now skip if (item.Hash == RightItem.Hash)
// else if (item.Hash > RightItem.Hash)
{
var newRight = Right.AddOrUpdate(item);
return(!IsEmerged(newRight, Right)
? new TwoItemsTree(LeftItem, RightItem, Left, Middle, newRight)
: (INode) new OneItemTree(RightItem, new OneItemTree(LeftItem, Left, Middle), newRight));
}
}
public TernaryTrieNode <V> Get(char charKey)
{
var response = charKey.CompareTo(CharKey);
if (response < 0)
{
if (Left != null)
{
return(Left.Get(charKey));
}
return(null);
}
else if (response > 0)
{
if (Right != null)
{
Right.Get(charKey);
}
return(null);
}
else
{
if (Middle != null)
{
Middle.Get(charKey);
}
return(null);
}
}
public bool Equals(IName other)
{
return(First.Equals(other.First, StringComparison.CurrentCultureIgnoreCase) &&
Middle.Equals(other.Middle, StringComparison.CurrentCultureIgnoreCase) &&
Last.Equals(other.Last, StringComparison.CurrentCultureIgnoreCase) &&
Gender.Equals(other.Gender));
}
public override string ToString()
{
return(string.Join("&",
"pauseMiddle=" + Middle.ToString(),
"pauseLong=" + Long.ToString(),
"pauseSentence=" + Sentence.ToString()));
}
/// <summary>
/// Called on each bar update event (incoming tick)
/// </summary>
protected override void OnBarUpdate()
{
// calculate Linear Regression
double sumX = (double)Period * (Period - 1) * 0.5;
double divisor = sumX * sumX - (double)Period * Period * (Period - 1) * (2 * Period - 1) / 6;
double sumXY = 0;
for (int count = 0; count < Period && CurrentBar - count >= 0; count++)
{
sumXY += count * Input[count];
}
y.Set(Input[0]);
double slope = ((double)Period * sumXY - sumX * SUM(y, Period)[0]) / divisor;
double intercept = (SUM(y, Period)[0] - slope * sumX) / Period;
double linReg = intercept + slope * (Period - 1);
// Calculate Standard Error
double sumSquares = 0;
for (int count = 0; count < Period && CurrentBar - count >= 0; count++)
{
double linRegX = intercept + slope * (Period - 1 - count);
double valueX = Input[count];
double diff = Math.Abs(valueX - linRegX);
sumSquares += diff * diff;
}
double stdErr = Math.Sqrt(sumSquares / Period);
Middle.Set(linReg);
Upper.Set(linReg + stdErr);
Lower.Set(linReg - stdErr);
}
public Middle SingleNest()
{
Object[] objects = { new Middle(), new Bottom(), new Bottom() };
Middle middle = _composer.Compose <Middle>(objects);
return(middle);
}
public void Update()
{
if (scollWheelChanged)
{
ScrollWheelVelocity = scrollWheelVelocity;
scollWheelChanged = false;
}
else
{
ScrollWheelVelocity = 0;
}
Left.Update(leftOn);
Middle.Update(middleOn);
Right.Update(rightOn);
IntPtr w2, w3;
int x, y, x2, y2;
uint mask;
Reign.Core.X11.XQueryPointer(input.application.DC, input.application.Handle, out w2, out w3, out x, out y, out x2, out y2, out mask);
lastPosition = Position;
Position = new Point2(x2, input.application.FrameSize.Height - y2);
PositionVector = Position.ToVector2();
Velocity = Position - lastPosition;
VelocityVector = Velocity.ToVector2();
}
/// <summary>
/// Check Name equality.
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public bool Equals(Name name) => name == null ? false :
Suffix.Equals(name.Suffix) &&
(
ReferenceEquals(this.Suffix, name.Suffix) ||
Suffix != null &&
Suffix.Equals(name.Suffix)
) &&
(
ReferenceEquals(this.First, name.First) ||
First != null &&
First.Equals(name.First)
) &&
(
ReferenceEquals(this.Middle, name.Middle) ||
Middle != null &&
Middle.Equals(name.Middle)
) &&
(
ReferenceEquals(this.Last, name.Last) ||
Last != null &&
Last.Equals(name.Last)
) &&
(
ReferenceEquals(this.Prefix, name.Prefix) ||
Prefix != null &&
Prefix.Equals(name.Prefix)
) &&
(
ReferenceEquals(this.IsOrganization, name.IsOrganization) ||
IsOrganization.Equals(name.IsOrganization)
);
static void Main(string[] args)
{
Wage ivanov = new Director();
ivanov = new Overtime(ivanov);
ivanov = new Premium(ivanov);
Console.WriteLine(ivanov.info());
Wage petrov = new Junior();
petrov = new Late(petrov);
petrov = new Late(petrov);
petrov = new Late(petrov);
Console.WriteLine(petrov.info());
Wage novikov = new Middle();
novikov = new Late(novikov);
novikov = new Overtime(novikov);
novikov = new Overtime(novikov);
novikov = new Deal(novikov);
Console.WriteLine(novikov.info());
Wage andreev = new Middle();
andreev = new Overtime(andreev);
andreev = new Overtime(andreev);
andreev = new Deal(andreev);
andreev = new Deal(andreev);
andreev = new Deal(andreev);
andreev = new Deal(andreev);
andreev = new Premium(andreev);
Console.WriteLine(andreev.info());
}
/// <summary>
/// Punch appropriate holes for the selected code charts.
/// </summary>
/// <param name="safeList">The safe list to punch through.</param>
/// <param name="codeCharts">The code charts to punch.</param>
private static void PunchCodeCharts(ref char[][] safeList, MidCodeCharts codeCharts)
{
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.GreekExtended), Middle.GreekExtended());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.GeneralPunctuation), Middle.GeneralPunctuation());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.SuperscriptsAndSubscripts), Middle.SuperscriptsAndSubscripts());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.CurrencySymbols), Middle.CurrencySymbols());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.CombiningDiacriticalMarksForSymbols), Middle.CombiningDiacriticalMarksForSymbols());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.LetterlikeSymbols), Middle.LetterlikeSymbols());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.NumberForms), Middle.NumberForms());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.Arrows), Middle.Arrows());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.MathematicalOperators), Middle.MathematicalOperators());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousTechnical), Middle.MiscellaneousTechnical());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.ControlPictures), Middle.ControlPictures());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.OpticalCharacterRecognition), Middle.OpticalCharacterRecognition());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.EnclosedAlphanumerics), Middle.EnclosedAlphanumerics());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.BoxDrawing), Middle.BoxDrawing());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.BlockElements), Middle.BlockElements());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.GeometricShapes), Middle.GeometricShapes());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousSymbols), Middle.MiscellaneousSymbols());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.Dingbats), Middle.Dingbats());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousMathematicalSymbolsA), Middle.MiscellaneousMathematicalSymbolsA());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.SupplementalArrowsA), Middle.SupplementalArrowsA());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.BraillePatterns), Middle.BraillePatterns());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.SupplementalArrowsB), Middle.SupplementalArrowsB());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousMathematicalSymbolsB), Middle.MiscellaneousMathematicalSymbolsB());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.SupplementalMathematicalOperators), Middle.SupplementalMathematicalOperators());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.MiscellaneousSymbolsAndArrows), Middle.MiscellaneousSymbolsAndArrows());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.Glagolitic), Middle.Glagolitic());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.LatinExtendedC), Middle.LatinExtendedC());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.Coptic), Middle.Coptic());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.GeorgianSupplement), Middle.GeorgianSupplement());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.Tifinagh), Middle.Tifinagh());
PunchHolesIfNeeded(ref safeList, Middle.IsFlagSet(codeCharts, MidCodeCharts.BlockElements), Middle.EthiopicExtended());
}
/// <summary>
/// Is the specified object equivalent to this instance? (All fields identical)
/// </summary>
/// <param name="obj">The object to compare.</param>
/// <returns><see langword="true"/>, if the object is a <see cref="PersonName"/> and ALL fields are identical; otherwise, <see langword="false"/></returns>
public override bool Equals(object obj)
{
if (!(obj is PersonName pn))
{
return(false);
}
if (First.HasChanges(pn.First))
{
return(false);
}
if (Last.HasChanges(pn.Last))
{
return(false);
}
if (Middle.HasChanges(pn.Middle))
{
return(false);
}
if (Prefix.HasChanges(pn.Prefix))
{
return(false);
}
if (Suffix.HasChanges(pn.Suffix))
{
return(false);
}
if (Nickname.HasChanges(pn.Nickname))
{
return(false);
}
return(true);
}
private async void UpdatePosition(object sender, EventArgs e)
{
var downloaded = media.GetMediaInfo(file).Duration.TotalSeconds *downloader.Status.Progress;
var seconds = Player.MediaPosition / 10000000;
TimeLine.Maximum = downloaded;
TimeLine.Value = seconds;
DownloadSpeed.Text = GetSpeed(downloader.Status.DownloadRate);
UploadSpeed.Text = GetSpeed(downloader.Status.UploadRate);
SetValue(downloader.Status.Progress);
CurrentTime.Text = GetTime(seconds) + "/" + GetTime((float)downloaded);
if (seconds >= downloaded - 5)
{
Player.Pause();
Middle.Visibility = Visibility.Visible;
Middle.BeginStoryboard((Storyboard)FindResource("OpacityUp"));
while ((media.GetMediaInfo(file).Duration.TotalSeconds *downloader.Status.Progress) - 10 > seconds)
{
Animate();
await Task.Delay(1080);
}
var sb = (Storyboard)FindResource("OpacityDown");
var clone = sb.Clone();
clone.Completed += (s, ev) => {
Middle.Visibility = Visibility.Collapsed;
};
sb.Begin(Middle);
Player.Play();
}
}
public void Create_MiddleWithInvalidValues_ArgumentException()
{
// arrange
int[] data = ReadData();
// act
var res = new Middle(data[0], data[1]);
}
/// <summary>
/// The problem of integer programming:
/// Selection employees necessary to minimize the total cost
/// for given parameters of the cash amount and fixed productivity.
/// </summary>
/// <param name="selector">Contains cash amount and productivity</param>
/// <returns>Possible solutions for the composition of the team of employees</returns>
public override List <Dictionary <FellowWorker, int> > Select(StaffSelector selector)
{
SolverContext context = SolverContext.GetContext();
Model model = context.CreateModel();
// init fellow workers
Junior junior = selector.Staffs.Junior;
Middle middle = selector.Staffs.Middle;
Senior senior = selector.Staffs.Senior;
Lead lead = selector.Staffs.Lead;
// init decisions - counts of number of employees of different qualifications
Decision juniorDecision = new Decision(Domain.IntegerNonnegative, junior.GetQualificationString());
Decision middleDecision = new Decision(Domain.IntegerNonnegative, middle.GetQualificationString());
Decision seniorDecision = new Decision(Domain.IntegerNonnegative, senior.GetQualificationString());
Decision leadDecision = new Decision(Domain.IntegerNonnegative, lead.GetQualificationString());
model.AddDecisions(juniorDecision, middleDecision, seniorDecision, leadDecision);
// constraint of fixed productivity
model.AddConstraints("fixProductivity",
junior.Productivity * juniorDecision +
middle.Productivity * middleDecision +
senior.Productivity * seniorDecision +
lead.Productivity * leadDecision == selector.Productivity);
// constraint of max cash amount
model.AddConstraints("maxAmount",
junior.Salary * juniorDecision +
middle.Salary * middleDecision +
senior.Salary * seniorDecision +
lead.Salary * leadDecision <= selector.Amount);
// criterion of optimization - total cost
model.AddGoal("cost", GoalKind.Minimize,
junior.Salary * juniorDecision +
middle.Salary * middleDecision +
senior.Salary * seniorDecision +
lead.Salary * leadDecision);
Solution solution = context.Solve(new ConstraintProgrammingDirective());
// packing results
List <Dictionary <FellowWorker, int> > solutionsList = new List <Dictionary <FellowWorker, int> >();
while (solution.Quality != SolverQuality.Infeasible)
{
solutionsList.Add(PackSolutionInDictionary(new Decision[] {
juniorDecision,
middleDecision,
seniorDecision,
leadDecision
}, selector.Staffs));
solution.GetNext();
}
context.ClearModel();
return(solutionsList);
}
public void Set_MiddleInvalidProductivity_ArgumentException()
{
// arrange
Middle res = new Middle(10, 10);
// act
res.Salary = Convert.ToInt32(TestContext.DataRow[Productivity]);
}
/// <summary>
/// Moves the mouse to a new position. This will not fire any events or changed their arguments.
/// </summary>
/// <param name="position">The new mouse position in desktop space.</param>
public void SetPosition(Vector2 position)
{
_mouse.SetPosition(position);
Left.SetPosition(position);
Right.SetPosition(position);
Middle.SetPosition(position);
}
public Staffs(Junior junior, Middle middle, Senior senior, Lead lead)
{
this.Junior = junior;
this.Middle = middle;
this.Senior = senior;
this.Lead = lead;
this.staffsArray = new FellowWorker[] { junior, middle, senior, lead };
}
public void Plus()
{
var lhs = new Self("20");
var rhs = new Self("5");
var ans = Middle.Plus(lhs, rhs);
Assert.True(lhs + rhs == new Self("+25"));
Assert.True((Self)ans == new Self("+25"));
}
public void Quotient()
{
var lhs = new Self("64");
var rhs = new Self("5");
var ans = Middle.Quotient(lhs, rhs);
Assert.True(ans == new Self("12"));
Assert.True(ans != new Self("0"));
}
public void Modulo()
{
var lhs = new Self("64");
var rhs = new Self("5");
var ans = Middle.Modulo(lhs, rhs);
Assert.True(ans == new Self("4"));
Assert.True(ans != new Self("0"));
}
public string GetText()
{
if (Total == 0)
{
return(string.Join("\t", Enumerable.Repeat("", 5)));
}
return(Lower.ToString("P2") + "\t" + Middle.ToString("P2") + "\t" + Upper.ToString("P2") + "\t" + Num + "\t" + Total);
}
/// <summary>
/// Called on each bar update event (incoming tick)
/// </summary>
protected override void OnBarUpdate()
{
double smaValue = AhrensMA(period).AhrensHL[0];
double stdDevValue = StdDev(Period)[0];
Upper.Set(smaValue + NumStdDev * stdDevValue);
Middle.Set(smaValue);
Lower.Set(smaValue - NumStdDev * stdDevValue);
}
public void UpdateHand(FingerModel thumb, FingerModel index, FingerModel middle, FingerModel pinky,
FingerModel ring)
{
Thumb.UpdateFinger(thumb);
Index.UpdateFinger(index);
Middle.UpdateFinger(middle);
Ring.UpdateFinger(ring);
Pinky.UpdateFinger(pinky);
}
public override void editing(PropEditController propEditController)
{
findHandBehavior();
Thumb.apply();
Index.apply();
Middle.apply();
Ring.apply();
Pinky.apply();
}
// Start is called before the first frame update
void Start()
{
Left = GameObject.Find("Left");
Middle = GameObject.Find("Middle");
Right = GameObject.Find("Right");
Left.GetComponent <Renderer>().material.color = Color.red;
Middle.GetComponent <Renderer>().material.color = Color.blue;
Right.GetComponent <Renderer>().material.color = Color.green;
}
/// <summary>
/// Override of the <see cref="Object.GetHashCode"/> Method.
/// </summary>
/// <returns>A Hash-Code suitable for use in hashtables.</returns>
/// <remarks>Only considers the First, Middle, and Last names; ignores other fields.</remarks>
public override int GetHashCode()
{
unchecked {
int hash = 17;
hash = hash * 23 + (First.HasValue() ? First.GetHashCode() : 0);
hash = hash * 23 + (Last.HasValue() ? Last.GetHashCode() : 0);
hash = hash * 23 + (Middle.HasValue() ? Middle.GetHashCode() : 0);
return(hash);
}
}
public void SingleNest()
{
Composer composer = new Composer();
Object[] objects = { new Middle(), new Bottom() };
Middle middle = composer.Compose <Middle>(objects);
Assert.AreEqual(objects[0], middle);
Assert.AreEqual(objects[1], middle.Bottom);
}
public bool Equals(ViewValueDimensions other)
{
return(Width == other.Width &&
Height == other.Height &&
Middle.Equals(other.Middle) &&
Left == other.Left &&
Top == other.Top &&
Right == other.Right &&
Bottom == other.Bottom);
}
/// <summary>
/// Called on each bar update event (incoming tick)
/// </summary>
protected override void OnBarUpdate()
{
double smaValue = SMA(Period)[0];
double stdDevValue = StdDev(SMA(Range(), 20), period)[0];
Print("stdDevValue = " + stdDevValue);
Upper.Set(smaValue + NumStdDev * stdDevValue);
Middle.Set(smaValue);
Lower.Set(smaValue - NumStdDev * stdDevValue);
}
public void Create_MiddleWithValidValues_IsMiddle()
{
// arrange
int[] data = ReadData();
// act
var res = new Middle(data[0], data[1]);
// assert
Assert.IsInstanceOfType(res, typeof(Middle));
}
public Outer(Middle middle)
{
Middle = middle;
}
