private static int in_dstates(Spec s, Bunch bunch)
{
Dfa dfa;
if (!s.dfa_sets.TryGetValue(bunch.GetNFABit(), out dfa))
{
return -1;
}
return dfa.Label;
}
private void Init(int num_vals)
{
B = new Bunch <int>();
int i = 0;
for (i = 0; i < num_vals; i++)
{
B.Add(Vals[i & 0x0F]);
}
}
private static int add_to_dstates(Spec s, Bunch bunch)
{
Dfa dfa = Alloc.NewDfa(s);
dfa.SetNFASet(new List<Nfa>(bunch.GetNFASet()));
dfa.SetNFABit(new BitSet(bunch.GetNFABit()));
dfa.SetAccept(bunch.GetAccept());
dfa.SetAnchor(bunch.GetAnchor());
dfa.ClearMarked();
s.dfa_sets[dfa.GetNFABit()] = dfa;
return dfa.Label;
}
public void SelectedProperty_Selected_NavigateToBunchPageAsyncShouldBeCalled()
{
Mock <INavigationService> mockNavigationService = new Mock <INavigationService>();
Mock <IRepository> mockRepository = new Mock <IRepository>();
var mainListPageModel = new MainListPageModel(mockNavigationService.Object, mockRepository.Object);
var bunch = new Bunch("mango", "banana");
mockNavigationService.Setup(x => x.NavigateToBunchPageAsync(bunch));
mainListPageModel.Selected = bunch;
mockNavigationService.Verify(x => x.NavigateToBunchPageAsync(bunch), Times.Once());
}
public Task NavigateToBunchPageAsync(Bunch bunch)
{
var navigationPage = App.Current.MainPage as NavigationPage;
if (navigationPage != null)
{
return(navigationPage.PushAsync(new BunchPage(this, bunch)));
}
else
{
Application.Current.MainPage = new NavigationPage(new BunchPage(this, bunch));
}
return(Task.FromResult(true));
}
public static bool LeerArchivo()
{
Console.WriteLine("Leyendo Archivo ");
const string path = @"C:\Users\crs80162\Documents\Git\Clissold.CSVReader\Clissold.CSVReader\Archivo\StockUpdater.xlsx";
List <BunchBO> BunchList = new List <BunchBO>();
const Decimal StdPieceMeter = 60;
int CurrentIndex = 0;
SLDocument sl = new SLDocument(path);
for (int iRow = 2; !string.IsNullOrEmpty(sl.GetCellValueAsString(iRow, 1)); iRow++)
{
string mtrCal = sl.GetCellValueAsString(iRow, 8);
if (mtrCal.Contains("P/E"))
{
mtrCal = mtrCal.Replace("P/E", "");
}
BunchBO Pieza = new BunchBO
{
Dte = sl.GetCellValueAsString(iRow, 1),
Name = sl.GetCellValueAsString(iRow, 2),
SetNO = sl.GetCellValueAsString(iRow, 4),
REF = sl.GetCellValueAsString(iRow, 3),
Created = DateTime.Today.ToShortDateString(),
Month = DateTime.Now.ToString("MMMM"),
Nopces = sl.GetCellValueAsString(iRow, 8),
Quality = sl.GetCellValueAsString(iRow, 5),
Design = sl.GetCellValueAsString(iRow, 6),
Shade = sl.GetCellValueAsString(iRow, 7),
Meters = Decimal.Parse(mtrCal) * StdPieceMeter
};
BunchList.Add(Pieza);
CurrentIndex++;
ProgressBar.DrawProgressBar(CurrentIndex, BunchList.Count);
}
Console.WriteLine("\n\r");
Console.WriteLine("Items Agregados:" + BunchList.Count);
if (NextStep())
{
Bunch.Delete();// Borrar stock Modificar mas adelante...
Bunch.Guardar(BunchList);
}
Console.WriteLine("\n\r Cerrando consola");
Thread.Sleep(1500);
return(true);
}
public void Bunch_Has_FoodGroup_Of_First_Member()
{
var myFoodOne = new MyFood
{
FoodGroup = FoodGroup.Fruit,
FoodValue = 10
};
var myFoodTwo = new MyFood
{
FoodGroup = FoodGroup.Fruit,
FoodValue = 15
};
var bunch = new Bunch <MyFood>(new[] { myFoodOne, myFoodTwo });
bunch.FoodGroup.Should().Be(FoodGroup.Fruit);
}
public void Bunch_Has_Sum_Of_FoodValue()
{
var myFoodOne = new MyFood
{
FoodGroup = FoodGroup.Fruit,
FoodValue = 10
};
var myFoodTwo = new MyFood
{
FoodGroup = FoodGroup.Fruit,
FoodValue = 15
};
var bunch = new Bunch <MyFood>(new[] { myFoodOne, myFoodTwo });
bunch.FoodValue.Should().Be(25);
}
private static void make_dtrans(Spec s)
{
Console.WriteLine("Working on DFA states.");
s.InitUnmarkedDFA();
int num = s.state_rules.Length;
s.state_dtrans = new int[num];
for (int i = 0; i < num; i++)
{
Bunch bunch = new Bunch(s.state_rules[i]);
bunch.e_closure();
Nfa2Dfa.add_to_dstates(s, bunch);
s.state_dtrans[i] = s.dtrans_list.Count;
Dfa nextUnmarkedDFA;
while ((nextUnmarkedDFA = s.GetNextUnmarkedDFA()) != null)
{
nextUnmarkedDFA.SetMarked();
DTrans dTrans = new DTrans(s, nextUnmarkedDFA);
for (int j = 0; j < s.dtrans_ncols; j++)
{
bunch.move(nextUnmarkedDFA, j);
if (!bunch.IsEmpty())
{
bunch.e_closure();
}
int num2;
if (bunch.IsEmpty())
{
num2 = -1;
}
else
{
num2 = Nfa2Dfa.in_dstates(s, bunch);
if (num2 == -1)
{
num2 = Nfa2Dfa.add_to_dstates(s, bunch);
}
}
dTrans.SetDTrans(j, num2);
}
s.dtrans_list.Add(dTrans);
}
}
Console.WriteLine("");
}
private void Awake()
{
Debug.Log("Awake Robot");
SM = GameObject.Find("/MainCamera").GetComponent <SceneManage>();
animator = gameObject.GetComponent <Animator>();
mineExpansion = gameObject.GetComponentInParent <MineExpansion>();
bunch = mineExpansion.GetComponentInChildren <Bunch>();
energy = gameObject.transform.Find("Body/Energy").gameObject;
energy.SetActive(false);
track = gameObject.transform.Find("Track").gameObject;
track.SetActive(false);
Leg = gameObject.transform.Find("Leg/Leg2").gameObject;
Leg2 = gameObject.transform.Find("Leg2/Leg2").gameObject;
pickaxe = gameObject.transform.Find("Arm/Pickaxe").gameObject;
spritesRenderer = gameObject.GetComponentsInChildren <SpriteRenderer>();
//Разная скорость передвижения, чтобы роботы не сливались
Scale = transform.localScale.x;
Speed = Random.Range(0.25f, 0.5f);
UpSpeed = Random.Range(1f, 1.5f);
BonusSpeed = Random.Range(1.5f, 2f);
UpBonusSpeed = Random.Range(3f, 4f);
}
public static void Main()
{
int index = 0;
int x;
int[] mas1 = { 1, 2, 3, 4, 5 },
mas2 = { 1, 1, -1, 1, 1 },
mas3 = { 1, -1 };
string[] mas = { "Hello", "HI" };
Bunch <string> elem0 = new Bunch <string>(mas);
elem0.add(1, "abc");
WriteLine("elem0:\n" + elem0.ToString());
Bunch <int> elem1 = new Bunch <int>(mas1);
Bunch <int> elem2 = new Bunch <int>(mas1);
Bunch <int> elem3 = new Bunch <int>(mas3);
WriteLine("elem1 = elem2: " + elem1.Equals(elem2).ToString());
WriteLine("elem1:\n" + elem1.ToString());
elem1.Security = false;
elem1.add(0, 6);
WriteLine("elem1:\n" + elem1.ToString());
x = 5;
elem1.delete(ref x, out index);
WriteLine("elem1:\n" + elem1.ToString());
WriteLine(index);
WriteLine("elem1:\n" + elem1.ToString());
WriteLine("elem1 = elem3: " + elem1.Equals(elem3).ToString());
Bunch <int>[] elem4 = { elem1, elem2, elem3, new Bunch <int>(mas2) };
for
WriteLine("elem4:\n" + elem4);
double max = elem4[0].Sum, min = elem4[0].Sum;
int max_i = 0, min_i = 0;
Write("Множества содержащие отрицательные элементы: ");
for (int i = 0; i < elem4.Length; i++)
{
if (elem4[i].Sum > max)
{
max = elem4[i].Sum;
max_i = i;
}
if (elem4[i].Sum < min)
{
min = elem4[i].Sum;
min_i = i;
}
if (elem4[i].Negative == true)
{
Write(i.ToString() + " ");
}
}
WriteLine();
WriteLine("Номер множества с максимальной суммой: " + max_i.ToString() + '\n'
+ "Номер множества с минимальной суммой: " + min_i.ToString());
var elem5 = new { Count = mas1.Length, field = new List <int>(mas1) };
Bunch <int> .Info();
ReadKey();
}
public BunchPage(INavigationService navigationService, Bunch bunch)
{
InitializeComponent();
BindingContext = new BunchPageModel(navigationService, bunch);
}
public BunchPageModel(INavigationService navigationService, Bunch bunch)
{
_navigationService = navigationService;
_bunch = bunch;
}
public void Update_CalledWithCorrectJson_BunchItemsIsUpdatedCorrectly()
{
var repository = new Repository();
repository.Update(testJson1);
var updatedBunchList = repository.BunchList;
Bunch targetBunch = null;
foreach (var bunch in updatedBunchList)
{
if (bunch.Id.Equals("bunch_a"))
{
targetBunch = bunch;
}
}
Assert.IsNotNull(targetBunch);
repository.Update(testJson2);
var bunchItemList = targetBunch.ItemList;
BunchItem mangoItem = null;
foreach (var bunchItem in bunchItemList)
{
Console.WriteLine($"bunchItem {bunchItem.Id}, {bunchItem.Content}, {bunchItem.IsActive}");
if (bunchItem.Id.Equals("mango"))
{
mangoItem = bunchItem;
}
}
Assert.IsNotNull(mangoItem);
Assert.IsFalse(mangoItem.IsActive);
Assert.AreEqual(mangoItem.Content, "mango_content");
repository.Update(testJson3);
bunchItemList = targetBunch.ItemList;
mangoItem = null;
BunchItem orangeItem = null;
BunchItem bananaItem = null;
foreach (var bunchItem in bunchItemList)
{
Console.WriteLine($"bunchItem {bunchItem.Id}, {bunchItem.Content}, {bunchItem.IsActive}");
if (bunchItem.Id.Equals("mango"))
{
mangoItem = bunchItem;
}
else if (bunchItem.Id.Equals("orange"))
{
orangeItem = bunchItem;
}
else if (bunchItem.Id.Equals("banana"))
{
bananaItem = bunchItem;
}
}
Assert.IsNull(mangoItem);
Assert.IsNotNull(bananaItem);
Assert.IsFalse(bananaItem.IsActive);
Assert.AreEqual(bananaItem.Content, "banana_content");
Assert.IsNotNull(orangeItem);
Assert.IsTrue(orangeItem.IsActive);
Assert.AreEqual(orangeItem.Content, "orange_content");
}
public string Format(ModalityData data, string numberFormat = null, IFormatProvider numberFormatProvider = null)
{
Assertion.NotNull(nameof(data), data);
var outlierDetectorFactory = OutlierDetectorFactory ?? SimpleOutlierDetectorFactory.DoubleMad;
numberFormat ??= "N2";
numberFormatProvider ??= DefaultCultureInfo.Instance;
bool compactMode = CompactMiddleModes && data.Modality > 2;
var modes = compactMode
? new[] { data.Modes.First(), data.Modes.Last() }
: data.Modes;
var builder = new StringBuilder();
var bunch = new Bunch();
bool isFirst = true;
void AddBunch(char open, string multiSeparator, char close)
{
if (bunch.Any())
{
if (isFirst)
{
isFirst = false;
}
else
{
builder.Append(GroupSeparator);
}
bunch.Present(builder, open, multiSeparator, close, PresentCount, numberFormat, numberFormatProvider);
}
}
void AddMode() => AddBunch('[', "; ", ']');
void AddOutliers() => AddBunch('{', "..", '}');
void AddMiddleNodesIfNeeded(int index)
{
if (index == 0 && compactMode)
{
int extraModes = data.Modality - 2;
if (isFirst)
{
isFirst = false;
}
else
{
builder.Append(GroupSeparator);
}
builder.Append('<');
builder.Append(extraModes);
builder.Append(' ');
builder.Append(extraModes > 1 ? "modes" : "mode");
builder.Append('>');
}
}
if (PresentOutliers)
{
for (int i = 0; i < modes.Count; i++)
{
var mode = modes[i];
var outlierDetector = outlierDetectorFactory.Create(mode.Values);
int index = 0;
// *Lower outliers*
while (index < mode.Values.Count && outlierDetector.IsLowerOutlier(mode.Values[index]))
{
bunch.Add(mode.Values[index++]);
}
if (!(compactMode && i != 0))
{
AddOutliers();
}
bunch.Clear();
// *Central values*
while (index < mode.Values.Count && !outlierDetector.IsOutlier(mode.Values[index]))
{
bunch.Add(mode.Values[index++]);
}
if (PresentModeLocations)
{
bunch.Mode = mode.Location;
}
AddMode();
bunch.Clear();
// *Upper outliers*
while (index < mode.Values.Count && outlierDetector.IsUpperOutlier(mode.Values[index]))
{
bunch.Add(mode.Values[index++]);
}
// Propagate bunch to the lower outliers of the next mode
AddMiddleNodesIfNeeded(i);
}
AddOutliers(); // Upper outliers of the last mode
}
else
{
for (int i = 0; i < modes.Count; i++)
{
var mode = modes[i];
bunch.Min = mode.Min();
bunch.Max = mode.Max();
if (PresentModeLocations)
{
bunch.Mode = mode.Location;
}
bunch.Count = mode.Values.Count;
AddBunch('[', "; ", ']');
AddMiddleNodesIfNeeded(i);
}
}
return(builder.ToString());
}
