void TriggerBackward()
{
if (Backward != null)
{
Backward.Invoke(this, new EventArgs());
}
}
public void Draw(Effect effect)
{
if (UpVisible)
{
Up.Draw(effect);
}
if (DownVisible)
{
Down.Draw(effect);
}
if (ForwardVisible)
{
Forward.Draw(effect);
}
if (BackwardVisible)
{
Backward.Draw(effect);
}
if (LeftVisible)
{
Left.Draw(effect);
}
if (RightVisible)
{
Right.Draw(effect);
}
}
// Use this for initialization
void Start()
{
script = GameObject.Find("Button Backward").GetComponent <Backward>();
clickedBack = false;
anim = GetComponent <Animator> ();
// anim.SetBool ("ClickedB",clickedBack);
}
public void MoveFromOvestDirection_ObstaclePoint_ThrowException()
{
var B = new Backward();
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
RoverMars R = new RoverMars('O');
R.Position.X = 1;
R.Position.Y = 2;
B.MoveFromOvestDirection(R, G);
}
public void UpdateUnusedAssets()
{
var all = new HashSet <string>(_forward.Keys);
var withBacklinks =
new HashSet <string>(Backward.Where(kv => kv.Value.Lookup.Count > 0).Select(kv => kv.Key));
all.ExceptWith(withBacklinks);
all.RemoveWhere(SearchUtils.IsFileIgrnoredBySettings);
var unusedAssets = all;
var scenes = unusedAssets.Where(s =>
AssetDatabase.GetMainAssetTypeAtPath(s).IsAssignableFromInverse(typeof(SceneAsset))).ToArray();
unusedAssets.ExceptWith(scenes);
var files = unusedAssets;
UnusedFiles = new Dictionary <string, long>();
foreach (var file in files)
{
UnusedFiles[file] = CommonUtils.Size(file);
}
UnusedScenes = new Dictionary <string, long>();
foreach (var scene in scenes)
{
UnusedScenes[scene] = CommonUtils.Size(scene);
}
// UpdateFoldersWithQty();
foreach (var folder in Folders)
{
var unusedFilesQty = UnusedFiles.Count(p => p.Key.StartsWith(folder));
var unusedScenesQty = UnusedScenes.Count(p => p.Key.StartsWith(folder));
long size = 0;
size = UnusedFiles.Where((p => p.Key.StartsWith(folder))).Sum(p => p.Value);
size += UnusedScenes.Where(p => p.Key.StartsWith(folder)).Sum(p => p.Value);
FoldersWithQty.TryGetValue(folder, out var folderWithQty);
if (folderWithQty == null)
{
FoldersWithQty.Add(folder, new UnusedQty(unusedFilesQty, unusedScenesQty, size));
}
else
{
folderWithQty.UnusedFilesQty = unusedFilesQty;
folderWithQty.UnusedScenesQty = unusedScenesQty;
folderWithQty.UnusedSize = size;
}
}
}
public void MoveFromSudDirection_ObstaclePoint_ThrowException()
{
var B = new Backward();
RoverMars R = new RoverMars('N');
// this case should never happen but this class does not know
// i give to the rover an impossible point
R.Position.X = 2;
R.Position.Y = 1;
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
B.MoveFromSudDirection(R, G);
}
public void MoveFromOvestDirection_NewRoverPoint_OutOfGridValueLessThenZero_Expected_NewXEqualsMaxXOfGrid()
{
{
var B = new Backward();
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
RoverMars R = new RoverMars('O');
R.Position.X = -2;
R.Position.Y = 2;
B.MoveFromOvestDirection(R, G);
Point expectedNewRoverPosition = new Point(5, 2);
Assert.AreEqual(expectedNewRoverPosition, R.Position);
}
}
public void BackwardTest()
{
var f = new Forward {
Id = 33, Name = "phil", Location = "here", Number = 12345
};
var b = new Backward();
b.InjectFrom <Reverse>(f);
Console.WriteLine(b.dI); // 33
Console.WriteLine(b.emaN); // phil
Console.WriteLine(b.noitacoL); // here
Console.WriteLine(b.rebmuN); // 12345
}
public void MoveFromNordDirection_NewRoverPoint_OutOfGrid_Expected_NewYEqualsZero()
{
var B = new Backward();
RoverMars R = new RoverMars('N');
R.Position.X = 1;
R.Position.Y = 7;
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
B.MoveFromNordDirection(R, G);
Point expectedNewRoverPosition = new Point(1, 0);
Assert.AreEqual(expectedNewRoverPosition, R.Position);
}
void ReleaseDesignerOutlets()
{
if (Backward != null)
{
Backward.Dispose();
Backward = null;
}
if (DateInput != null)
{
DateInput.Dispose();
DateInput = null;
}
if (FeedName != null)
{
FeedName.Dispose();
FeedName = null;
}
if (FeedSelection != null)
{
FeedSelection.Dispose();
FeedSelection = null;
}
if (Forward != null)
{
Forward.Dispose();
Forward = null;
}
if (NoContent != null)
{
NoContent.Dispose();
NoContent = null;
}
if (NoMenu != null)
{
NoMenu.Dispose();
NoMenu = null;
}
if (WebView != null)
{
WebView.Dispose();
WebView = null;
}
}
public void MoveFromOvestDirection_NewRoverPoint_OutOfGrid_Expected_NewXEqualsZero()
{
var B = new Backward();
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
RoverMars R = new RoverMars('O');
//rover orientation is ovest direction
R.Position.X = 5;
R.Position.Y = 1;
B.MoveFromOvestDirection(R, G);
Point expectedNewRoverPosition = new Point(0, 1);
Assert.AreEqual(expectedNewRoverPosition, R.Position);
}
public void MoveFromEstDirection_MoveRoverInXMinusOne()
{
var B = new Backward();
RoverMars R = new RoverMars('E');
R.Position.X = 1;
R.Position.Y = 1;
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
B.MoveFromEstDirection(R, G);
Point expectedNewRoverPosition = new Point(0, 1);
Assert.AreEqual(expectedNewRoverPosition, R.Position);
}
public void MoveFromEstDirection_NewRoverPoint_OutOfGrid_Expected_NewXEqualsZero()
{
Backward B = new Backward();
RoverMars R = new RoverMars('E');
R.Position.X = 7;
R.Position.Y = 1;
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
B.MoveFromEstDirection(R, G);
Point expectedNewRoverPosition = new Point(0, 1);
Assert.AreEqual(expectedNewRoverPosition, R.Position);
}
public void RebuildFor(string path, bool remove)
{
if (!_forward.TryGetValue(path, out var fwMeta))
{
fwMeta = new FwMeta();
_forward.Add(path, fwMeta);
}
else if (remove)
{
foreach (var dependency in fwMeta.Dependencies)
{
if (!Backward.TryGetValue(dependency, out var backDep))
{
continue;
}
backDep.Lookup.Remove(path);
}
fwMeta.Dependencies = null;
}
var dependencies = _Dependencies(path);
fwMeta.Dependencies = new HashSet <string>(dependencies);
foreach (var backPath in dependencies)
{
if (!Backward.TryGetValue(backPath, out var bwMeta))
{
bwMeta = new BwMeta {
Lookup = new HashSet <string>()
};
Backward.Add(backPath, bwMeta);
}
else if (remove)
{
bwMeta.Lookup.Remove(path);
}
bwMeta.Lookup.Add(path);
}
if (!remove)
{
UpdateFoldersWithQtyByPath(path);
}
}
public void MoveFromOvestDirection_MoveRoverInXPluOne()
{
Backward B = new Backward();
//rover orientation is ovest direction, is not responsibility of this class check direction
RoverMars R = new RoverMars('O');
//rover actual position is 1,1
R.Position.X = 1;
R.Position.Y = 1;
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
B.MoveFromOvestDirection(R, G);
Point expectedNewRoverPosition = new Point(2, 1);
Assert.AreEqual(expectedNewRoverPosition, R.Position);
}
void Start()
{
right = GameObject.Find("Right").GetComponent <Right>();
rightMR = GameObject.Find("Right").GetComponent <MeshRenderer>();
left = GameObject.Find("Left").GetComponent <Left>();
leftMR = GameObject.Find("Left").GetComponent <MeshRenderer>();
forward = GameObject.Find("Forward").GetComponent <Forward>();
forwardMR = GameObject.Find("Forward").GetComponent <MeshRenderer>();
backward = GameObject.Find("Backward").GetComponent <Backward>();
backwardMR = GameObject.Find("Backward").GetComponent <MeshRenderer>();
gm = GameObject.Find("GameManager").GetComponent <GameManager>();
transform.position = gm.playerStartingPosition;
isMoving = false;
canMoveRight = false;
playerIsCaught = false;
}
public void MoveFromSudDirection_NewRoverPoint_OutOfGridValueLessThenZero_Expected_NewYEqualsMaxYOfGrid()
{
var B = new Backward();
RoverMars R = new RoverMars('N');
// this case should never happen but this class does not know
// i give to the rover an impossible point
R.Position.X = 1;
R.Position.Y = -2;
Grid G = new Grid(5, 5, new FakeObstacleGenerator());
B.MoveFromSudDirection(R, G);
Point expectedNewRoverPosition = new Point(1, 5);
Assert.AreEqual(expectedNewRoverPosition, R.Position);
}
public void Remove(string path)
{
if (!_forward.TryGetValue(path, out var fwMeta))
{
return;
}
foreach (var dependency in fwMeta.Dependencies)
{
if (!Backward.TryGetValue(dependency, out var dep))
{
continue;
}
dep.Lookup.Remove(path);
}
_forward.Remove(path);
UpdateFoldersWithQtyByPath(path);
}
void _FillFwAndBacklinks(string path)
{
var dependencies = _Dependencies(path);
var hs = new FwMeta {
Dependencies = new HashSet <string>(dependencies)
};
_forward.Add(path, hs);
foreach (var backPath in dependencies)
{
if (!Backward.TryGetValue(backPath, out var val))
{
val = new BwMeta();
val.Lookup = new HashSet <string>();
Backward.Add(backPath, val);
}
val.Lookup.Add(path);
}
}
void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
Effect.Dispose();
Up.Dispose();
Down.Dispose();
Forward.Dispose();
Backward.Dispose();
Left.Dispose();
Right.Dispose();
}
disposed = true;
}
public void Update(float frameTime, MovementInput input)
{
Forward += (input.Forward ? Acceleration : Deceleration) * frameTime;
Backward += (input.Backward ? Acceleration : Deceleration) * frameTime;
Leftward += (input.Leftward ? Acceleration : Deceleration) * frameTime;
Rightward += (input.Rightward ? Acceleration : Deceleration) * frameTime;
Upward += (input.Upward ? Acceleration : Deceleration) * frameTime;
Downward += (input.Downward ? Acceleration : Deceleration) * frameTime;
var maxVelocity = Constants.MaxVelocity;
if (input.Sprint)
{
maxVelocity *= 3;
}
Forward = Forward.Clamp(0.0f, maxVelocity);
Backward = Backward.Clamp(0.0f, maxVelocity);
Leftward = Leftward.Clamp(0.0f, maxVelocity);
Rightward = Rightward.Clamp(0.0f, maxVelocity);
Upward = Upward.Clamp(0.0f, maxVelocity);
Downward = Downward.Clamp(0.0f, maxVelocity);
}
private void UpdateCameraInput(Camera c, int index)
{
int x = InputHelper.NewMouse.X;
int y = InputHelper.NewMouse.Y;
if (!_isDragged && CameraContains(c, x, y) || _isDragged && _currentCamera == index)
{
_currentCamera = index;
if (MouseCondition.Scrolled())
{
int scrollDelta = MouseCondition.ScrollDelta;
SetZoom(c, MathF.Min(MathF.Max(GetZoom(c) - scrollDelta * 0.001f, 0.2f), 10f));
}
if (RotateLeft.Pressed())
{
c.Rotation += MathHelper.PiOver4;
}
if (RotateRight.Pressed())
{
c.Rotation -= MathHelper.PiOver4;
}
if (Forward.Held())
{
c.Z -= 0.1f;
}
if (Backward.Held())
{
c.Z += 0.1f;
}
if (IncreaseFocal.Held())
{
var temp = c.Z / c.FocalLength;
c.FocalLength += 0.01f;
c.Z = c.FocalLength * temp;
}
if (DecreaseFocal.Held())
{
var temp = c.Z / c.FocalLength;
c.FocalLength -= 0.01f;
c.Z = c.FocalLength * temp;
}
if (ResetCamera.Pressed())
{
c.Scale = new Vector2(1f, 1f);
c.XY = new Vector2(0f, 0f);
c.Z = 2f;
c.Rotation = 0f;
c.FocalLength = 1f;
}
_mouseWorld = c.ScreenToWorld(x, y);
if (CameraDrag.Pressed())
{
_dragAnchor = _mouseWorld;
_isDragged = true;
}
if (_isDragged && CameraDrag.HeldOnly())
{
c.XY += _dragAnchor - _mouseWorld;
_mouseWorld = _dragAnchor;
}
if (_isDragged && CameraDrag.Released())
{
_isDragged = false;
}
}
}
private void OnBackwardButton_Click(object sender, RoutedEventArgs e) => Backward?.Invoke(this, EventArgs.Empty);
public override int go()
{
int i, j, k, stage, n, isize, jend, ksize, j1, buffer_size, c, m, p, jstart; /* requests(2), statuses(MPI_STATUS_SIZE, 2);*/
double r1, r2, d, e, sm1, sm2;
double[] s = new double[5];
double[] in_buffer_y;
double[] out_buffer_y;
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// if (timeron) timer.start(t_ysolve);
//---------------------------------------------------------------------
// now do a sweep on a layer-by-layer basis, i.e. sweeping through cells
// on this node in the direction of increasing i for the forward sweep,
// and after that reversing the direction for the backsubstitution
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// FORWARD ELIMINATION
//---------------------------------------------------------------------
for (stage = 0; stage < ncells; stage++)
{
Lhs.enterStage(stage);
Forward.enterStage(stage);
c = slice[stage, 1];
jstart = 2;
jend = 2 + cell_size[c, 1] - 1;
isize = cell_size[c, 0] + 2;
ksize = cell_size[c, 2] + 2;
buffer_size = (isize - start[c, 0] - end[c, 0]) * (ksize - start[c, 2] - end[c, 2]);
Input_buffer_forward.Array = in_buffer_y = new double[22 * buffer_size];
Output_buffer_forward.Array = out_buffer_y = new double[22 * buffer_size];
if (stage != 0)
{
Shift_forward.initiate_recv();
Lhs.go();
Shift_forward.go();
#region read buffer
//---------------------------------------------------------------------
// unpack the buffer
//---------------------------------------------------------------------
j = jstart;
j1 = jstart + 1;
n = -1;
//---------------------------------------------------------------------
// create a running pointer
//---------------------------------------------------------------------
p = 0;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (i = start[c, 0]; i < isize - end[c, 0]; i++)
{
// Console.WriteLine("in_buffer_y_f["+ p + "] = " + in_buffer_y[p]);
// Console.WriteLine("in_buffer_y_f["+ (p+1) + "] = " + in_buffer_y[p+1]);
lhs[c, k, j, i, n + 2] = lhs[c, k, j, i, n + 2] -
in_buffer_y[p] * lhs[c, k, j, i, n + 1];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] -
in_buffer_y[p + 1] * lhs[c, k, j, i, n + 1];
for (m = 0; m <= 2; m++)
{
// Console.WriteLine("in_buffer_y_f["+ (p+2+m) + "] = " + in_buffer_y[p+2+m]);
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
in_buffer_y[p + 2 + m] * lhs[c, k, j, i, n + 1];
}
// Console.WriteLine("in_buffer_y_f["+ (p+5) + "] = " + in_buffer_y[p+5]);
// Console.WriteLine("in_buffer_y_f["+ (p+6) + "] = " + in_buffer_y[p+6]);
d = in_buffer_y[p + 5];;
e = in_buffer_y[p + 6];
for (m = 0; m <= 2; m++)
{
// Console.WriteLine("in_buffer_y_f["+ (p+7+m) + "] = " + in_buffer_y[p+7+m]);
s[m] = in_buffer_y[p + 7 + m];
}
r1 = lhs[c, k, j, i, n + 2];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] - d * r1;
lhs[c, k, j, i, n + 4] = lhs[c, k, j, i, n + 4] - e * r1;
for (m = 0; m <= 2; m++)
{
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] - s[m] * r1;
}
r2 = lhs[c, k, j1, i, n + 1];
lhs[c, k, j1, i, n + 2] = lhs[c, k, j1, i, n + 2] - d * r2;
lhs[c, k, j1, i, n + 3] = lhs[c, k, j1, i, n + 3] - e * r2;
for (m = 0; m <= 2; m++)
{
rhs[c, k, j1, i, m] = rhs[c, k, j1, i, m] - s[m] * r2;
}
p = p + 10;
}
}
for (m = 3; m <= 4; m++)
{
n = (m - 2) * 5 - 1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (i = start[c, 0]; i < isize - end[c, 0]; i++)
{
lhs[c, k, j, i, n + 2] = lhs[c, k, j, i, n + 2] -
in_buffer_y[p] * lhs[c, k, j, i, n + 1];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] -
in_buffer_y[p + 1] * lhs[c, k, j, i, n + 1];
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
in_buffer_y[p + 2] * lhs[c, k, j, i, n + 1];
d = in_buffer_y[p + 3];
e = in_buffer_y[p + 4];
s[m] = in_buffer_y[p + 5];
r1 = lhs[c, k, j, i, n + 2];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] - d * r1;
lhs[c, k, j, i, n + 4] = lhs[c, k, j, i, n + 4] - e * r1;
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] - s[m] * r1;
r2 = lhs[c, k, j1, i, n + 1];
lhs[c, k, j1, i, n + 2] = lhs[c, k, j1, i, n + 2] - d * r2;
lhs[c, k, j1, i, n + 3] = lhs[c, k, j1, i, n + 3] - e * r2;
rhs[c, k, j1, i, m] = rhs[c, k, j1, i, m] - s[m] * r2;
p = p + 6;
}
}
}
#endregion
}
else
{
Lhs.go();
}
Forward.go();
//---------------------------------------------------------------------
// send information to the next processor, except when this
// is the last grid block;
//---------------------------------------------------------------------
if (stage != ncells - 1)
{
#region write buffer
//---------------------------------------------------------------------
// create a running pointer for the send buffer
//---------------------------------------------------------------------
p = 0;
n = -1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (i = start[c, 0]; i < isize - end[c, 0]; i++)
{
for (j = jend - 1; j <= jend; j++)
{
out_buffer_y[p] = lhs[c, k, j, i, n + 4];
out_buffer_y[p + 1] = lhs[c, k, j, i, n + 5];
// Console.WriteLine("out_buffer_y["+ p + "] = " + out_buffer_y[p]);
// Console.WriteLine("out_buffer_y["+ (p+1) + "] = " + out_buffer_y[p+1]);
for (m = 0; m <= 2; m++)
{
out_buffer_y[p + 2 + m] = rhs[c, k, j, i, m];
// Console.WriteLine("out_buffer_y["+ (p+2+m) + "] = " + out_buffer_y[p+2+m]);
}
p = p + 5;
}
}
}
for (m = 3; m <= 4; m++)
{
n = (m - 2) * 5 - 1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (i = start[c, 0]; i < isize - end[c, 0]; i++)
{
for (j = jend - 1; j <= jend; j++)
{
out_buffer_y[p] = lhs[c, k, j, i, n + 4];
out_buffer_y[p + 1] = lhs[c, k, j, i, n + 5];
out_buffer_y[p + 2] = rhs[c, k, j, i, m];
// Console.WriteLine("out_buffer_y["+ (p) + "] = " + out_buffer_y[p]);
// Console.WriteLine("out_buffer_y["+ (p+1) + "] = " + out_buffer_y[p+1]);
// Console.WriteLine("out_buffer_y["+ (p+2) + "] = " + out_buffer_y[p+2]);
p = p + 3;
}
}
}
}
#endregion
Shift_forward.initiate_send();
}
}
//---------------------------------------------------------------------
// now go in the reverse direction
//---------------------------------------------------------------------
//---------------------------------------------------------------------
// BACKSUBSTITUTION
//---------------------------------------------------------------------
for (stage = ncells - 1; stage >= 0; stage--)
{
Backward.enterStage(stage);
c = slice[stage, 1];
jstart = 2;
jend = 2 + cell_size[c, 1] - 1;
isize = cell_size[c, 0] + 2;
ksize = cell_size[c, 2] + 2;
buffer_size = (isize - start[c, 0] - end[c, 0]) *
(ksize - start[c, 2] - end[c, 2]);
Input_buffer_backward.Array = in_buffer_y = new double[10 * buffer_size];
Output_buffer_backward.Array = out_buffer_y = new double[10 * buffer_size];
if (stage != ncells - 1)
{
Shift_backward.initiate_recv();
Matvecproduct.enterStage(stage + 1);
Matvecproduct.go();
Shift_backward.go();
#region read_buffer
//---------------------------------------------------------------------
// unpack the buffer for the first three factors
//---------------------------------------------------------------------
n = -1;
p = 0;
j = jend;
j1 = j - 1;
for (m = 0; m <= 2; m++)
{
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (i = start[c, 0]; i < isize - end[c, 0]; i++)
{
// Console.WriteLine("in_buffer_y["+ p + "] = " + in_buffer_y[p]);
// Console.WriteLine("in_buffer_y["+ (p+1) + "] = " + in_buffer_y[p+1]);
sm1 = in_buffer_y[p];
sm2 = in_buffer_y[p + 1];
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
lhs[c, k, j, i, n + 4] * sm1 -
lhs[c, k, j, i, n + 5] * sm2;
rhs[c, k, j1, i, m] = rhs[c, k, j1, i, m] -
lhs[c, k, j1, i, n + 4] * rhs[c, k, j, i, m] -
lhs[c, k, j1, i, n + 5] * sm1;
p = p + 2;
}
}
}
//---------------------------------------------------------------------
// now unpack the buffer for the remaining two factors
//---------------------------------------------------------------------
for (m = 3; m <= 4; m++)
{
n = (m - 2) * 5 - 1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (i = start[c, 0]; i < isize - end[c, 0]; i++)
{
// Console.WriteLine("in_buffer_y["+ p + "] = " + in_buffer_y[p]);
// Console.WriteLine("in_buffer_y["+ (p+1) + "] = " + in_buffer_y[p+1]);
sm1 = in_buffer_y[p];
sm2 = in_buffer_y[p + 1];
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
lhs[c, k, j, i, n + 4] * sm1 -
lhs[c, k, j, i, n + 5] * sm2;
rhs[c, k, j1, i, m] = rhs[c, k, j1, i, m] -
lhs[c, k, j1, i, n + 4] * rhs[c, k, j, i, m] -
lhs[c, k, j1, i, n + 5] * sm1;
p = p + 2;
}
}
}
#endregion
}
else
{
Backward.init();
}
Backward.go();
//---------------------------------------------------------------------
// send on information to the previous processor, if needed
//---------------------------------------------------------------------
if (stage != 0)
{
#region write buffer
j = jstart;
j1 = jstart + 1;
p = 0;
for (m = 0; m <= 4; m++)
{
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (i = start[c, 0]; i < isize - end[c, 0]; i++)
{
out_buffer_y[p] = rhs[c, k, j, i, m];
out_buffer_y[p + 1] = rhs[c, k, j1, i, m];
p = p + 2;
}
}
}
#endregion
Shift_backward.initiate_send();
}
//---------------------------------------------------------------------
// If this was the last stage, do the block-diagonal inversion
//---------------------------------------------------------------------
if (stage == 0)
{
Matvecproduct.enterStage(stage);
Matvecproduct.go();
}
}
return(0);
} // end activate method
public override int go()
{
int c, i, j, k, n, iend, jsize, ksize, i1, i2, m, buffer_size, p, istart, stage;
double r1, r2, d, e, sm1, sm2, fac1, fac2;
double[] s = new double[5];
double[] in_buffer_x;
double[] out_buffer_x;
for (stage = 0; stage < ncells; stage++)
{
Forward.enterStage(stage);
Lhs.enterStage(stage);
c = slice[stage, 0];
istart = 2;
iend = 2 + cell_size[c, 0] - 1;
jsize = cell_size[c, 1] + 2;
ksize = cell_size[c, 2] + 2;
buffer_size = (jsize - start[c, 1] - end[c, 1]) *
(ksize - start[c, 2] - end[c, 2]);
Input_buffer_forward.Array = in_buffer_x = new double[22 * buffer_size];
Output_buffer_forward.Array = out_buffer_x = new double[22 * buffer_size];
if (stage != 0)
{
Shift_forward.initiate_recv();
Lhs.go();
Shift_forward.go();
#region read buffer
//---------------------------------------------------------------------
// unpack the buffer
//---------------------------------------------------------------------
i = istart;
i1 = istart + 1;
n = -1;
//---------------------------------------------------------------------
// create a running pointer
//---------------------------------------------------------------------
p = 0;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (j = start[c, 1]; j < jsize - end[c, 1]; j++)
{
//Console.WriteLine("in_buffer_x["+ p + "] = " + in_buffer_x[p]);
//Console.WriteLine("in_buffer_x["+ (p+1) + "] = " +in_buffer_x[p+1]);
lhs[c, k, j, i, n + 2] = lhs[c, k, j, i, n + 2] -
in_buffer_x[p] * lhs[c, k, j, i, n + 1];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] -
in_buffer_x[p + 1] * lhs[c, k, j, i, n + 1];
for (m = 0; m <= 2; m++)
{
// Console.WriteLine("in_buffer_x["+ (p+2+m) + "] = " +in_buffer_x[p+2+m]);
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
in_buffer_x[p + 2 + m] * lhs[c, k, j, i, n + 1];
}
//Console.WriteLine("in_buffer_x["+ (p+5) + "] = " +in_buffer_x[p+5]);
//Console.WriteLine("in_buffer_x["+ (p+6) + "] = " +in_buffer_x[p+6]);
d = in_buffer_x[p + 5];
e = in_buffer_x[p + 6];
for (m = 0; m <= 2; m++)
{
//Console.WriteLine("in_buffer_x["+ (p+5) + "] = " +in_buffer_x[p+5]);
//Console.WriteLine(in_buffer_x[p+7+m]);
s[m] = in_buffer_x[p + 7 + m];
}
r1 = lhs[c, k, j, i, n + 2];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] - d * r1;
lhs[c, k, j, i, n + 4] = lhs[c, k, j, i, n + 4] - e * r1;
for (m = 0; m <= 2; m++)
{
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] - s[m] * r1;
}
r2 = lhs[c, k, j, i1, n + 1];
lhs[c, k, j, i1, n + 2] = lhs[c, k, j, i1, n + 2] - d * r2;
lhs[c, k, j, i1, n + 3] = lhs[c, k, j, i1, n + 3] - e * r2;
for (m = 0; m <= 2; m++)
{
rhs[c, k, j, i1, m] = rhs[c, k, j, i1, m] - s[m] * r2;
}
p = p + 10;
}
}
for (m = 3; m <= 4; m++)
{
n = (m - 2) * 5 - 1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (j = start[c, 1]; j < jsize - end[c, 1]; j++)
{
lhs[c, k, j, i, n + 2] = lhs[c, k, j, i, n + 2] -
in_buffer_x[p] * lhs[c, k, j, i, n + 1];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] -
in_buffer_x[p + 1] * lhs[c, k, j, i, n + 2];
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
in_buffer_x[p + 2] * lhs[c, k, j, i, n + 1];
d = in_buffer_x[p + 3];
e = in_buffer_x[p + 4];
s[m] = in_buffer_x[p + 5];
r1 = lhs[c, k, j, i, n + 2];
lhs[c, k, j, i, n + 3] = lhs[c, k, j, i, n + 3] - d * r1;
lhs[c, k, j, i, n + 4] = lhs[c, k, j, i, n + 4] - e * r1;
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] - s[m] * r1;
r2 = lhs[c, k, j, i1, n + 1];
lhs[c, k, j, i1, n + 2] = lhs[c, k, j, i1, n + 2] - d * r2;
lhs[c, k, j, i1, n + 3] = lhs[c, k, j, i1, n + 3] - e * r2;
rhs[c, k, j, i1, m] = rhs[c, k, j, i1, m] - s[m] * r2;
p = p + 6;
}
}
}
#endregion
}
else
{
Lhs.go();
}
Forward.go();
//---------------------------------------------------------------------
// send information to the next processor, except when this
// is the last grid block
//---------------------------------------------------------------------
if (stage != ncells - 1)
{
#region write buffer
//---------------------------------------------------------------------
// create a running pointer for the send buffer
//---------------------------------------------------------------------
p = 0;
n = -1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (j = start[c, 1]; j < jsize - end[c, 1]; j++)
{
for (i = iend - 1; i <= iend; i++)
{
out_buffer_x[p] = lhs[c, k, j, i, n + 4];
out_buffer_x[p + 1] = lhs[c, k, j, i, n + 5];
for (m = 0; m <= 2; m++)
{
out_buffer_x[p + 2 + m] = rhs[c, k, j, i, m];
}
p = p + 5;
}
}
}
for (m = 3; m <= 4; m++)
{
n = (m - 2) * 5 - 1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (j = start[c, 1]; j < jsize - end[c, 1]; j++)
{
for (i = iend - 1; i <= iend; i++)
{
out_buffer_x[p] = lhs[c, k, j, i, n + 4];
out_buffer_x[p + 1] = lhs[c, k, j, i, n + 5];
out_buffer_x[p + 2] = rhs[c, k, j, i, m];
p = p + 3;
}
}
}
}
#endregion
Shift_forward.initiate_send();
}
} // cells loop
//---------------------------------------------------------------------
// BACKSUBSTITUTION
//---------------------------------------------------------------------
for (stage = ncells - 1; stage >= 0; stage--)
{
Backward.enterStage(stage);
c = slice[stage, 0];
istart = 2;
iend = 2 + cell_size[c, 0] - 1;
jsize = cell_size[c, 1] + 2;
ksize = cell_size[c, 2] + 2;
buffer_size = (jsize - start[c, 1] - end[c, 1]) * (ksize - start[c, 2] - end[c, 2]);
in_buffer_x = Input_buffer_backward.Array = new double[10 * buffer_size];
out_buffer_x = Output_buffer_backward.Array = new double[10 * buffer_size];
if (stage != ncells - 1)
{
Shift_backward.initiate_recv();
Matvecproduct.enterStage(stage + 1);
Matvecproduct.go();
Shift_backward.go();
#region read_buffer_x_back
//---------------------------------------------------------------------
// unpack the buffer for the first three factors
//---------------------------------------------------------------------
n = -1;
p = 0;
i = iend;
i1 = i - 1;
for (m = 0; m <= 2; m++)
{
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (j = start[c, 1]; j < jsize - end[c, 1]; j++)
{
// Console.WriteLine("in_buffer_x["+ p + "] = " + in_buffer_x[p]);
// Console.WriteLine("in_buffer_x["+ (p+1) + "] = " + in_buffer_x[p+1]);
sm1 = in_buffer_x[p];
sm2 = in_buffer_x[p + 1];
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
lhs[c, k, j, i, n + 4] * sm1 -
lhs[c, k, j, i, n + 5] * sm2;
rhs[c, k, j, i1, m] = rhs[c, k, j, i1, m] -
lhs[c, k, j, i1, n + 4] * rhs[c, k, j, i, m] -
lhs[c, k, j, i1, n + 5] * sm1;
p = p + 2;
}
}
}
//---------------------------------------------------------------------
// now unpack the buffer for the remaining two factors
//---------------------------------------------------------------------
for (m = 3; m <= 4; m++)
{
n = (m - 2) * 5 - 1;
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (j = start[c, 1]; j < jsize - end[c, 1]; j++)
{
// Console.WriteLine("in_buffer_x["+ p + "] = " + in_buffer_x[p]);
// Console.WriteLine("in_buffer_x["+ (p+1) + "] = " + in_buffer_x[p+1]);
sm1 = in_buffer_x[p];
sm2 = in_buffer_x[p + 1];
rhs[c, k, j, i, m] = rhs[c, k, j, i, m] -
lhs[c, k, j, i, n + 4] * sm1 -
lhs[c, k, j, i, n + 5] * sm2;
rhs[c, k, j, i1, m] = rhs[c, k, j, i1, m] -
lhs[c, k, j, i1, n + 4] * rhs[c, k, j, i, m] -
lhs[c, k, j, i1, n + 5] * sm1;
p = p + 2;
}
}
}
#endregion
}
else
{
Backward.init();
}
Backward.go();
//---------------------------------------------------------------------
// send on information to the previous processor, if needed
//---------------------------------------------------------------------
if (stage != 0)
{
#region write buffer
i = istart;
i1 = istart + 1;
p = 0;
for (m = 0; m <= 4; m++)
{
for (k = start[c, 2]; k < ksize - end[c, 2]; k++)
{
for (j = start[c, 1]; j < jsize - end[c, 1]; j++)
{
out_buffer_x[p] = rhs[c, k, j, i, m];
out_buffer_x[p + 1] = rhs[c, k, j, i1, m];
p = p + 2;
}
}
}
#endregion
Shift_backward.initiate_send();
}
//if (timeron) timer.stop(t_xsolve);
//---------------------------------------------------------------------
// If this was the last stage, do the block-diagonal inversion
//---------------------------------------------------------------------
if (stage == 0)
{
Matvecproduct.enterStage(stage);
Matvecproduct.go();
}
}
return(0);
} // end activate method
private void ForwardButtonClick(object sender, RoutedEventArgs e)
{
Backward?.Invoke(this, EventArgs.Empty);
}
