public IActionResult Numbers() { NumberArray newnumarr = new NumberArray() { numArr = new int[] { 1, 2, 3, 10, 43, 5 } }; return(View("Numbers", newnumarr)); }
public void TestCopyNumberArrayBlock() { VariableBlock[] blocks = new VariableBlock[2]; blocks[0] = new Constant(10, "a", "", false); blocks[1] = new NumberArray("cake", blocks[0], ""); int[][] dependencyGraph = new int[][] { new int[] { }, new int[] { 0 } }; CheckCopyMultiBlock(blocks[1], blocks, dependencyGraph); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @TestFactory Stream<org.junit.jupiter.api.DynamicTest> shouldHandleMultipleCallsToClose() internal virtual Stream <DynamicTest> ShouldHandleMultipleCallsToClose() { return(DynamicTest.stream(ArrayFactories(), NumberArrayFactoryName, factory => { // GIVEN NumberArray <object> array = factory.newIntArray(10, -1); // WHEN array.Close(); // THEN should also work array.Close(); })); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void doRace(System.Func<NumberArray,int,Runnable> contestantCreator) throws Throwable private void DoRace(System.Func <NumberArray, int, ThreadStart> contestantCreator) { PageCache pageCache = _pageCacheRule.getPageCache(_fs); PagedFile file = pageCache.Map(_dir.file("file"), pageCache.PageSize(), CREATE, DELETE_ON_CLOSE); Race race = new Race(); using (NumberArray array = GetNumberArray(file)) { for (int i = 0; i < CONTESTANTS; i++) { race.AddContestant(contestantCreator(array, i)); } race.Go(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @TestFactory Stream<org.junit.jupiter.api.DynamicTest> shouldGetAndSetRandomItems() internal virtual Stream <DynamicTest> ShouldGetAndSetRandomItems() { ThrowingConsumer <NumberArrayTestData> throwingConsumer = data => { using (NumberArray array = data.array) { IDictionary <int, object> key = new Dictionary <int, object>(); Reader reader = data.reader; object defaultValue = reader.read(array, 0); // WHEN setting random items for (int i = 0; i < INDEXES * 2; i++) { int index = _random.Next(INDEXES); object value = data.valueGenerator.apply(_random); data.writer.write(i % 2 == 0 ? array : array.at(index), index, value); key.put(index, value); } // THEN they should be read correctly AssertAllValues(key, defaultValue, reader, array); // AND WHEN swapping some for (int i = 0; i < INDEXES / 2; i++) { int fromIndex = _random.Next(INDEXES); int toIndex; do { toIndex = _random.Next(INDEXES); } while (toIndex == fromIndex); object fromValue = reader.read(array, fromIndex); object toValue = reader.read(array, toIndex); key.put(fromIndex, toValue); key.put(toIndex, fromValue); array.swap(fromIndex, toIndex); } // THEN they should end up in the correct places AssertAllValues(key, defaultValue, reader, array); } }; return(DynamicTest.stream(Arrays().GetEnumerator(), data => data.name, throwingConsumer)); }
public override async Task Sort() { for (int x = NumberArray.Count(); x > 1; x--) { for (int y = 0; y < NumberArray.Count() - 1; y++) { if (NumberArray.ElementAt(y).CompareTo(NumberArray.ElementAt(y + 1)) > 0) { SelectedIndices = new [] { y, y + 1 }; NumberArray = Swap.SwapItem(NumberArray, y, y + 1); TriggerNumbersUpdatedEvent(); } await Sleep(UserInterfaceViewModel.Delay).ConfigureAwait(false); } } SelectedIndices = null; }
public override async Task Sort() { for (int i = 0; i < NumberArray.Count() - 1; i++) { int arrayNum = i; for (int j = i + 1; j < NumberArray.Count(); j++) { SelectedIndices = new[] { j, i }; if (NumberArray.ElementAt(j).CompareTo(NumberArray.ElementAt(i)) < 0 && NumberArray.ElementAt(arrayNum).CompareTo(NumberArray.ElementAt(j)) > 0) { arrayNum = j; } await Sleep(UserInterfaceViewModel.Delay).ConfigureAwait(false); } // Swap SelectedIndices = new[] { i, arrayNum }; NumberArray = Swap.SwapItem(NumberArray, i, arrayNum); TriggerNumbersUpdatedEvent(); } SelectedIndices = null; }
protected internal override ThreadStart FileRangeRacer(NumberArray array, int contestant) { return(new FileRangeRacer(this, ( PageCacheIntArray )array, contestant)); }
///<inheritdoc/> public void InitTable(ITable subtable) { Table = subtable; commands = new StringArray(); ids = new NumberArray(); toCancel = new NumberArray(); Table.PutValue("Names", commands); Table.PutValue("Ids", ids); Table.PutValue("Cancel", toCancel); }
protected internal override ThreadStart WholeFileRacer(NumberArray array, int contestant) { return(new WholeFileRacer(this, ( ByteArray )array)); }
/** * An array of numbers that shall be taken pairwise to define a series of * points that describes the bounds of an area for which geospatial * transformations are valid. * * @param bounds */ virtual public void SetBounds(NumberArray bounds) { base.Put(PdfName.BOUNDS, bounds); }
/** * An array of numbers that shall be taken pairwise to define points in a 2D * unit square. The unit square is mapped to the rectangular bounds of the * {@link Viewport}, image XObject, or forms XObject that contains the * measure dictionary. This array shall contain the same number of number * pairs as the GPTS array; each number pair is the unit square object * position corresponding to the geospatial position in the GPTS array. * * @param pairedpoints */ virtual public void SetLPTS(NumberArray pairedpoints) { Put(PdfName.LPTS, pairedpoints); }
/** * An array of numbers that shall be taken pairwise, defining points in * geographic space as degrees of latitude and longitude. These values shall * be based on the geographic coordinate system described in the GCS * dictionary. * * @param pairedpoints */ public void SetGPTS(NumberArray pairedpoints) { Put(PdfName.GPTS, pairedpoints); }
private static void AssertAllValues(IDictionary <int, object> key, object defaultValue, Reader reader, NumberArray array) { for (int index = 0; index < INDEXES; index++) { object value = reader.read(index % 2 == 0 ? array : array.at(index), index); object expectedValue = key.getOrDefault(index, defaultValue); if (value is long[]) { assertArrayEquals(( long[] )expectedValue, ( long[] )value, "index " + index); } else { assertEquals(expectedValue, value, "index " + index); } } }
protected internal abstract ThreadStart WholeFileRacer(NumberArray array, int contestant);
public static Block ParseBlock(XmlNode node, DFG <Block> dfg, ParserInfo parserInfo, bool allowDeclarationBlocks = false, bool canBeScheduled = true) { string id = node.GetAttributeValue(Block.ID_FIELD_NAME); string blockType = node.GetAttributeValue(Block.TYPE_FIELD_NAME); switch (blockType) { case ArithOP.XML_TYPE_NAME: return(ArithOP.Parse(node, dfg, parserInfo, canBeScheduled)); case Constant.XML_TYPE_NAME: return(Constant.Parse(node, parserInfo, canBeScheduled)); case FluidArray.XML_TYPE_NAME: return(FluidArray.Parse(node, dfg, parserInfo)); case SetArrayFluid.XML_TYPE_NAME: return(SetArrayFluid.Parse(node, dfg, parserInfo)); case Fluid.XML_TYPE_NAME: return(Fluid.Parse(node, dfg, parserInfo)); case InputDeclaration.XML_TYPE_NAME: if (!allowDeclarationBlocks) { parserInfo.ParseExceptions.Add(new ParseException(id, "Declaration blocks has to be at the top of the program.")); } return(InputDeclaration.Parse(node, parserInfo)); case OutputDeclaration.XML_TYPE_NAME: if (!allowDeclarationBlocks) { parserInfo.ParseExceptions.Add(new ParseException(id, "Declaration blocks has to be at the top of the program.")); } return(OutputDeclaration.Parse(node, parserInfo)); case WasteDeclaration.XML_TYPE_NAME: if (!allowDeclarationBlocks) { parserInfo.ParseExceptions.Add(new ParseException(id, "Declaration blocks has to be at the top of the program.")); } return(WasteDeclaration.Parse(node, parserInfo)); case HeaterDeclaration.XML_TYPE_NAME: if (!allowDeclarationBlocks) { parserInfo.ParseExceptions.Add(new ParseException(id, "Declaration blocks has to be at the top of the program.")); } return(HeaterDeclaration.Parse(node, parserInfo)); case OutputUsage.XML_TYPE_NAME: return(OutputUsage.Parse(node, dfg, parserInfo)); case WasteUsage.XML_TYPE_NAME: return(WasteUsage.Parse(node, dfg, parserInfo)); case DropletDeclaration.XML_TYPE_NAME: return(DropletDeclaration.Parse(node, parserInfo)); case BoolOP.XML_TYPE_NAME: return(BoolOP.Parse(node, dfg, parserInfo, canBeScheduled)); //case Sensor.XmlTypeName: // return Sensor.Parse(node); case GetNumberVariable.XML_TYPE_NAME: return(GetNumberVariable.Parse(node, parserInfo, canBeScheduled)); case SetNumberVariable.XML_TYPE_NAME: return(SetNumberVariable.Parse(node, dfg, parserInfo)); case GetDropletCount.XML_TYPE_NAME: return(GetDropletCount.Parser(node, parserInfo, canBeScheduled)); case GetArrayLength.XML_TYPE_NAME: return(GetArrayLength.Parse(node, parserInfo, canBeScheduled)); case ImportVariable.XML_TYPE_NAME: return(ImportVariable.Parse(node, parserInfo, canBeScheduled)); case NumberArray.XML_TYPE_NAME: return(NumberArray.Parse(node, dfg, parserInfo)); case GetArrayNumber.XML_TYPE_NAME: return(GetArrayNumber.Parse(node, dfg, parserInfo, canBeScheduled)); case SetArrayNumber.XML_TYPE_NAME: return(SetArrayNumber.Parse(node, dfg, parserInfo, canBeScheduled)); case RoundOP.XML_TYPE_NAME: return(RoundOP.Parse(node, dfg, parserInfo, canBeScheduled)); default: throw new UnknownBlockException(id); } }