protected override void SwapWithCurrent(uint index, SwapType swapType)
{
// If the value being swapped in is one we're inserting, record the index found or assigned
if (_currentRowAdding >= 0)
{
if (swapType == SwapType.Match)
{
_currentAddedArrayIndices[_currentRowAdding] = _assignedIndices[index];
}
else
{
_currentAddedArrayIndices[_currentRowAdding] = _uniqueValueCount++;
}
_currentRowAdding = -1;
}
// If this wasn't a match (key already found), swap in the keys and (new) index
if (swapType != SwapType.Match)
{
// If this is a swap, write all values
for (int i = 0; i < _keys.Length; ++i)
{
_keys[i].SwapCurrent(index);
}
// Swap the assigned index
int assignedIndexSwap = _assignedIndices[index];
_assignedIndices[index] = _currentAssignedIndex;
_currentAssignedIndex = assignedIndexSwap;
}
}
public Swap(double notional, DateTime maturity, DateTime effectiveDate, DateTime settlementDate, DateTime valuationDate, Dictionary<double,double> liborRate, Dictionary<double, double> disc,
double fixedRate, SwapType swapType)
{
CalcPayDates(effectiveDate, maturity, valuationDate);
this.notional = notional;
this.maturity = maturity;
this.effectiveDate = effectiveDate;
this.settlementDate = settlementDate;
this.valuationDate = valuationDate;
this.DiscRates = disc;
this.floatRates = liborRate;
this.fixedLeg = new FixedLeg();
this.floatingLeg = new FloatingLeg();
//fixed leg
this.fixedLeg.Notional = notional;
this.fixedLeg.ValuationDate = valuationDate;
this.fixedLeg.PayFrequency = 2;
this.fixedLeg.FixedLegRate = fixedRate;
this.fixedLeg.MaturityDate = maturity;
this.fixedLeg.CalcPayFixed();
this.fixedLeg.EffectiveDate = effectiveDate;
//floating leg
this.floatingLeg.EffectiveDate = effectiveDate;
this.floatingLeg.PayFrequency = 4;
this.floatingLeg.Notional = notional;
this.floatingLeg.ValuationDate = valuationDate;
this.floatingLeg.FloatLegRate = liborRate;
this.floatingLeg.CalcPayFloat();
NetPayments();
CalcDV01();
}
protected override void SwapWithCurrent(uint index, SwapType swapType)
{
if (swapType == SwapType.Match)
{
return;
}
if (swapType == SwapType.Insert && _copier != null)
{
_currentKey = _copier.Copy(_currentKey);
}
if (swapType == SwapType.Insert && _currentIsNull)
{
_nullItemIndex = (int)index;
}
T swapKey = _keys[index];
int swapValue = _values[index];
_keys[index] = _currentKey;
_values[index] = _currentValue;
_currentKey = swapKey;
_currentValue = swapValue;
_currentIsNull = (_nullItemIndex == index);
}
public InfoRecord[] GetInfoRecords(ITranslationManager tm)
{
const string tg = "Statistics";
var records = new List <InfoRecord>
{
new InfoRecord
{
Name = tm.T(tg, "Type"),
Value = InstrType.ToString()
},
new InfoRecord
{
Name = tm.T(tg, "Comment"),
Value = Comment
},
new InfoRecord
{
Name = tm.T(tg, "Digits"),
Value = Digits.ToString(CultureInfo.InvariantCulture)
},
new InfoRecord
{
Name = tm.T(tg, "Point value"),
Value = Point.ToString("0.#####")
},
new InfoRecord
{
Name = tm.T(tg, "Lot size"),
Value = LotSize.ToString(CultureInfo.InvariantCulture)
},
new InfoRecord
{
Name = tm.T(tg, "Spread"),
Value = Spread.ToString("F2") + " " + tm.T(tg, "points")
},
new InfoRecord
{
Name = tm.T(tg, "Swap long"),
Value = SwapLong.ToString("F2") + " " + tm.T(tg, SwapType.ToString().ToLower())
},
new InfoRecord
{
Name = tm.T(tg, "Swap short"),
Value = SwapShort.ToString("F2") + " " + tm.T(tg, SwapType.ToString().ToLower())
},
new InfoRecord
{
Name = tm.T(tg, "Commission"),
Value = Commission.ToString("F2") + " " + tm.T(tg, CommissionType.ToString().ToLower())
},
new InfoRecord
{
Name = tm.T(tg, "Slippage"),
Value = Slippage.ToString("F2") + " " + tm.T(tg, "points")
}
};
return(records.ToArray());
}
protected override void SwapWithCurrent(uint index, SwapType swapType)
{
T swapKey = _keys[index];
U swapValue = _values[index];
_keys[index] = _currentKey;
_values[index] = _currentValue;
_currentKey = swapKey;
_currentValue = swapValue;
}
/// <summary>
/// Called to afirm that we are dealing with a drag swap
/// </summary>
/// <param name="animalSlot"></param>
/// <param name="startedPosition"></param>
private void EnableSwap(AnimalSlot animalSlot, Vector2 startedPosition)
{
_curSwapMode = SwapType.Drag;
if (_animalSlotDragMoving != null)
{
return;
}
_animalSlotDragMoving = animalSlot;
_mouseStart = startedPosition;
}
// Executes the swap.
public void AttempSwap(SwapType type)
{
if (type == SwapType.NORMAL && swapAvailable)
{
ActivateCover(swapHit, true);
}
else if (type == SwapType.JUMP && jumpSwapAvailable)
{
ActivateCover(jumpSwapHit, true);
}
}
private static List <SwapResult> GetPossibleSwaps(Grid grid, SwapType type)
{
List <SwapResult> result = new List <SwapResult>();
var limW = grid.Width;
var limH = grid.Height;
switch (type)
{
case SwapType.Right:
limW--;
break;
case SwapType.Down:
limH--;
break;
}
for (int i = 0; i < limW; i++)
{
for (int j = 0; j < limH; j++)
{
var testGrid = grid.Clone();
if (testGrid[i, j] == null)
{
continue;
}
var pointed = ActionFactory.GetBehaviour(testGrid[i, j]).Action(type);
var collapsing = testGrid.GetCollapsingCells().Union(pointed).ToList();
if (collapsing.Any())
{
SwapResult swap = new SwapResult()
{
X = i, Y = j, Direction = type
};
swap.Result = new CollapseResult(grid.Width);
while (collapsing.Any())
{
var newCollapsing = new List <CellItem>(collapsing);
foreach (var cellItem in collapsing)
{
newCollapsing.AddRange(ActionFactory.GetBehaviour(cellItem)
.Action(SwapType.Kill, newCollapsing));
}
swap.Result.Append(testGrid.Collapse(newCollapsing, swap.Generated));
collapsing = testGrid.GetCollapsingCells().Distinct().ToList();
swap.FinalGrid = testGrid;
}
result.Add(swap);
}
}
}
return(result);
}
public override List <CellItem> Action(SwapType action, List <CellItem> processed = null)
{
var touch = new List <CellItem>();
if (processed?.Contains(_item) == true)
{
return(touch);
}
touch.AddRange(processed ?? new List <CellItem>());
switch (action)
{
case SwapType.Point:
return(new List <CellItem>());
case SwapType.Down:
if (_item.Parent.Height <= _item.Position.Y + 1)
{
throw new MovementException($"Cant move cell {_item} down");
}
Swap(_item, _item.Position.X, _item.Position.Y + 1);
break;
case SwapType.Up:
if (_item.Position.Y - 1 < 0)
{
throw new MovementException($"Cant move cell {_item} up");
}
Swap(_item, _item.Position.X, _item.Position.Y - 1);
break;
case SwapType.Right:
if (_item.Parent.Width <= _item.Position.X + 1)
{
throw new MovementException($"Cant move cell {_item} right");
}
Swap(_item, _item.Position.X + 1, _item.Position.Y);
break;
case SwapType.Left:
if (_item.Position.X - 1 < 0)
{
throw new MovementException($"Cant move cell {_item} left");
}
Swap(_item, _item.Position.X - 1, _item.Position.Y);
break;
case SwapType.Kill:
touch.Add(_item);
break;
}
return(touch);
}
/// <summary>
/// Event called when user click on some animal, can be a drag or click until this moment
/// </summary>
/// <param name="animalSlot"></param>
public void OnAnimalClickDown(AnimalSlot animalSlot)
{
_curSwapMode = SwapType.Click;
UpdateCurAnimalDirections(animalSlot);
if (_possibleAnimalSlotMoving != null)
{
return;
}
_possibleAnimalSlotMoving = animalSlot;
_possibleMouseStart = Input.mousePosition;
}
/// <summary>
/// Return the vector direction that will be used for swap animals
/// </summary>
/// <param name="swapType"></param>
/// <returns></returns>
/// <exception cref="ArgumentOutOfRangeException"></exception>
private Vector2 GetDirectionToSwap(SwapType swapType)
{
switch (swapType)
{
case SwapType.Drag:
return((Vector2)Input.mousePosition - _mouseStart);
case SwapType.Click:
return(GetRandomDirection());
default:
throw new ArgumentOutOfRangeException(nameof(swapType), swapType, null);
}
}
/// <summary>
/// Called when we do a full click, so it is called also when we do a OnPointerUp event
/// </summary>
/// <param name="animalSlot"></param>
public void OnAnimalClick(AnimalSlot animalSlot)
{
//Cleaning possible values because we want to clear our mouse
if (_possibleAnimalSlotMoving != null)
{
_possibleAnimalSlotMoving = null;
}
_possibleMouseStart = Vector2.zero;
if (_possibleAnimalSlotMoving == null && _animalSlotDragMoving == null)
{
_animalSlotClickMoving = animalSlot;
_curSwapMode = SwapType.Click;
SwapAnimalByClick();
}
}
protected override void SwapWithCurrent(uint index, SwapType swapType)
{
// If the keys matched, compare the ranks
if (swapType == SwapType.Match)
{
if (_ranks.BetterThanCurrent(index, _chooseDirection))
{
// If the rank is better or we're swapping with a non-match, write the new rank and row
_ranks.SwapCurrent(index);
_bestRowIndices.SwapCurrent(index);
}
}
else
{
// Otherwise, write all values
for (int i = 0; i < _keys.Length; ++i)
{
_keys[i].SwapCurrent(index);
}
_ranks.SwapCurrent(index);
_bestRowIndices.SwapCurrent(index);
}
}
public override List <CellItem> Action(SwapType action, List <CellItem> processed = null)
{
var touch = new List <CellItem>();
if (processed?.Contains(_item) == true)
{
return(touch);
}
touch.AddRange(processed ?? new List <CellItem>());
switch (action)
{
case SwapType.Down:
if (_item.Parent.Height <= _item.Position.Y + 1)
{
throw new MovementException($"Cant move cell {_item} down");
}
Swap(_item, _item.Position.X, _item.Position.Y + 1);
break;
case SwapType.Up:
if (_item.Position.Y - 1 < 0)
{
throw new MovementException($"Cant move cell {_item} up");
}
Swap(_item, _item.Position.X, _item.Position.Y - 1);
break;
case SwapType.Right:
if (_item.Parent.Width <= _item.Position.X + 1)
{
throw new MovementException($"Cant move cell {_item} right");
}
Swap(_item, _item.Position.X + 1, _item.Position.Y);
break;
case SwapType.Left:
if (_item.Position.X - 1 < 0)
{
throw new MovementException($"Cant move cell {_item} left");
}
Swap(_item, _item.Position.X - 1, _item.Position.Y);
break;
case SwapType.Point:
case SwapType.Kill:
touch.Add(_item);
for (int i = 0; i < _item.Parent.Width; i++)
{
for (int j = 0; j < _item.Parent.Height; j++)
{
if (_item.Parent[i, j]?.Tag == _item.Tag)
{
touch.AddRange(ActionFactory.GetBehaviour(_item.Parent[i, j])
.Action(SwapType.Kill, touch));
}
}
}
break;
}
return(touch);
}
public override List <CellItem> Action(SwapType action, List <CellItem> processed = null)
{
return(processed ?? new List <CellItem>());
}
public Swap(SwapType swapType, Position original, Position replacement)
{
this.SwapType = swapType;
this.Original = original;
this.Replacement = replacement;
}
protected abstract void SwapWithCurrent(uint index, SwapType swapType);
public abstract List <CellItem> Action(SwapType action, List <CellItem> processed = null);
public static void DoSwap(string path, SwapType swapType)
{
if (path == null)
{
throw new ArgumentNullException("path",
"You must supply a path to the file.");
}
if (!File.Exists(path))
{
throw new FileNotFoundException("File not found.");
}
string tempPath = Path.GetTempFileName();
byte[] buffer = new byte[4096];
byte[] swapBytes = new byte[100];
using (FileStream inputFs = new FileStream(path, FileMode.Open,
FileAccess.Read))
using (FileStream outputFs = new FileStream(tempPath,
FileMode.Open, FileAccess.Write))
{
int bytesRead = -1;
if (swapType == SwapType.FrontToBack)
{
// We want to keep hold of the first 100 bytes of the file
// and output them after copying the rest of file
inputFs.Read(swapBytes, 0, 100);
}
else
{
// Read the last 100 bytes of the file
inputFs.Seek(-100, SeekOrigin.End);
inputFs.Read(swapBytes, 0, 100);
// Output them straight to the output file
outputFs.Write(swapBytes, 0, 100);
// Reposition to the beginning of the input file
inputFs.Seek(0, SeekOrigin.Begin);
}
// The number of bytes left to copy is 100 less than the file
// length
long bytesRemaining = inputFs.Length - 100;
// Copy the rest of the bytes
while (bytesRemaining > 0)
{
bytesRead = inputFs.Read(buffer, 0, buffer.Length);
// NB: the number of bytes read could be more than the
// number remaining
outputFs.Write(buffer, 0,
(int)Math.Min(bytesRead, bytesRemaining));
bytesRemaining -= bytesRead;
}
// Don't forget to append the start bytes if required
if (swapType == SwapType.FrontToBack)
{
outputFs.Write(swapBytes, 0, 100);
}
}
// Now swap the files themselves
File.Delete(path);
File.Move(tempPath, path);
// NB: could do File.Replace() if backup is needed
}