public DictArray(float[] values) { foreach (float f in values) { A.Add(new DictNumber(f)); } }
/// <summary> /// Creates a copy of a list with the items in random order. /// </summary> /// <param name="list"> /// The list to copy. /// </param> /// <param name="randNumGen"> /// An object that generates random numbers. /// </param> /// <returns> /// A copy of the list with its items shuffled (their order in the /// list is random). /// </returns> public static Generic.IList <T> Shuffle <T>(Generic.IList <T> list, System.Random randomNumGen) { if (list == null) { return(null); } Require.ArgumentNotNull(randomNumGen); // List of item indexes. Generic.List <int> indexes = new Generic.List <int>(list.Count); for (int i = 0; i < list.Count; ++i) { indexes.Add(i); } Generic.List <T> shuffledList = new Generic.List <T>(list.Count); while (indexes.Count > 0) { // Randomly pick a remaining item in the list int indexOfIndex = randomNumGen.Next(indexes.Count); int index = indexes[indexOfIndex]; indexes.RemoveAt(indexOfIndex); shuffledList.Add(list[index]); } return(shuffledList); }
// -- Private Methods -- /** * Returns an array of all the TileMaps object under a given node. */ private static Generic.List <TileMap> FindTilemapsUnder(Node root) { // Prepare the return list. Generic.List <TileMap> output = new Generic.List <TileMap>(); // Loop through all the children nodes. foreach (Node child in root.GetChildren()) { // If the object is a TileMap. if (child is TileMap) { // Add it to the result list. output.Add(child as TileMap); } // If the object has any children. if (child.GetChildCount() > 0) { // Add its sub-tilemaps to the list. output.AddRange(FindTilemapsUnder(child)); } } // Return the list. return(output); }
public void AddEdge(Edge edge) { if (!Edges.Contains(edge)) { Edges.Add(edge); } }
public void AddPoint(Vector2 point) { if (!Points.Contains(point)) { Points.Add(point); } }
/// <summary> /// Utility function to enable a list of LinkExtensions /// </summary> /// <param name="baseOptions"></param> /// <param name="linkExtensions"></param> /// <param name="enable"></param> public static void ChangeLinkExtensionEnableStatue(/*Deployment.DeploymentBaseOptions*/ dynamic baseOptions, System.Collections.Generic.List <string> linkExtensions, bool enable) { if (linkExtensions != null && linkExtensions.Count != 0) { foreach (string linkExtObj in linkExtensions) { RegularExpressions.Regex match = new RegularExpressions.Regex(linkExtObj, System.Text.RegularExpressions.RegexOptions.IgnoreCase); Generic.List <object> matchedList = new Generic.List <object>(); foreach (/*Deployment.DeploymentLinkExtension*/ dynamic linkExtension in baseOptions.LinkExtensions) { if (match.IsMatch(linkExtension.Name)) { matchedList.Add(linkExtension); } } if (matchedList.Count > 0) { foreach (/*Deployment.DeploymentLinkExtension*/ dynamic extension in matchedList) { extension.Enabled = enable; } } else { // throw new DeploymentException(Resources.UnknownLinkExtension, disableLink); //$Todo lmchen //Diagnostics.Debug.Assert(false, "NYI, we should prompt user for invalid LinkExtension"); throw new System.InvalidOperationException("UnknowLinkExtension"); } } } }
private readonly Generic.List <int> Xobjs = new Generic.List <int>(); // XObjects used by page ( typically images ) private void NoteXobj(int objnum) { if (!Xobjs.Contains(objnum)) { Xobjs.Add(objnum); } }
// Encodes a string as a list of Glyph indexes. public override void Encode(string s, int start, int end, Generic.List <byte> buf) { for (int i = start; i < end; i += 1) { char c = s[i]; if (c != '\n') { int uc = c; if (System.Char.IsSurrogate(c)) { uc = char.ConvertToUtf32(s, i); i += 1; } int gi = XG(Index(uc)); if (gi >= 0) // If char not found, it is simply ignored ( in future may want a fallback mechanism ). { buf.Add((byte)(gi >> 8)); buf.Add((byte)(gi & 0xff)); } } } }
bool KeepInstructions = false; // Are font instructions retained ( not implemented, would need additional tables to be copied to PDF ). int XG(int gi) // Translates a glyph index to the subset value. { if (gi < 0) { return(gi); } int x; if (!Xlat.TryGetValue(gi, out x)) { x = GList.Count; Xlat[gi] = x; GList.Add(gi); } return(x); }
private void ResolveTokens(string s) { int index = -1; int startIndex = 0; Generic.List <string> tokenParts = new Generic.List <string>(); //index = s.IndexOfAny(separators, startIndex); while ((index = s.IndexOfAny(separators, startIndex)) > 0) { int offset = index - startIndex; if (offset > 0) { tokenParts.Add(s.Substring(startIndex, index - startIndex)); } tokenParts.Add(s.Substring(index, 1)); startIndex = index + 1; } tokenParts.Add(s.Substring(startIndex)); tokenParts.Add(string.Empty); // TODO: Simulate EOL tokens = tokenParts.ToArray(); }
//ii.Highest Card wins public Generic.List <int> EvaluateWinners() { Generic.List <int> winningPlayerNumbers = new Generic.List <int>(); Generic.List <CardGameLibrary.PlayerOfCard> highestPlayersOfCards = new Generic.List <CardGameLibrary.PlayerOfCard>(); CardGameLibrary.PlayerOfCard highestPlayerOfCards = null; //Initially, assign first player as highest card winner if (PlayerOfCardsInGame.Count > 0) { highestPlayerOfCards = PlayerOfCardsInGame[0]; highestPlayersOfCards.Add(highestPlayerOfCards); } for (int i = 1; i < PlayerOfCardsInGame.Count; i++) { //If previous player(s) temporarily assigned //as highest card winner is outranked, remove //and add new player as currently //assigned highest card winner if (PlayerOfCardsInGame[i].PlayerScore > highestPlayerOfCards.PlayerScore) { highestPlayersOfCards.RemoveAll (match => match.PlayerScore == highestPlayerOfCards.PlayerScore); highestPlayerOfCards = PlayerOfCardsInGame[i]; highestPlayersOfCards.Add(highestPlayerOfCards); } //Multiple players having cards of same rank can be co-winners else if (PlayerOfCardsInGame[i].PlayerScore == highestPlayerOfCards.PlayerScore) { highestPlayerOfCards = PlayerOfCardsInGame[i]; highestPlayersOfCards.Add(highestPlayerOfCards); } } //This should be a list of at most Count == 4 for co-winner use-cases foreach (CardGameLibrary.PlayerOfCard playerOfCards in highestPlayersOfCards) { winningPlayerNumbers.Add(playerOfCards.PlayerNumber); } return(winningPlayerNumbers); }
void GetCmaps() { GotoTable(Tid.cmap); CmapLimit = IxLimit; uint cmapIx = Ix; Ix += 2; // Skip version uint numberSubtables = Get16(); for (int i = 0; i < numberSubtables; i += 1) { uint platformID = Get16(); uint platformSpecificID = Get16(); uint offset = Get32(); if (platformID == 0 || platformID == 3 && (platformSpecificID == 1 || platformSpecificID == 10)) // Is it a Unicode cmap? { Cmap.Add(cmapIx + offset); } } }
/// <summary> /// Retrieving SharePoint list collection /// </summary> /// <returns> SharePoint list collection</returns> public async Task <Generic.List <List> > GetLists() { Generic.List <List> resultLists = new Generic.List <List>(); IQueryable <List> listsWithIncludedProperty = ClientObjectQueryableExtension.Include(context.Web.Lists, list => list.Id, list => list.Title, list => list.ItemCount, list => list.Fields.Include(f => f.Title, f => f.Indexed, f => f.InternalName)); IQueryable <List> listCollection = listsWithIncludedProperty.Where(list => list.BaseType == BaseType.DocumentLibrary && (list.BaseTemplate == (int)ListTemplateType.DocumentLibrary || list.BaseTemplate == (int)ListTemplateType.MySiteDocumentLibrary) && list.Hidden == false); Generic.IEnumerable <List> lists = context.LoadQuery(listCollection); await ExecuteQuery(); lists.ForEach(list => resultLists.Add(list)); return(resultLists); }
public override void Encode(string s, int start, int end, Generic.List <byte> buf) { System.Text.Encoding enc = System.Text.Encoding.GetEncoding(1252); // Not sure if this is right. int len = end - start; int need = enc.GetMaxByteCount(len); if (need > EncBuffer.Length) { EncBuffer = Util.GetBuf(need); } int nb = enc.GetBytes(s, start, len, EncBuffer, 0); for (int i = 0; i < nb; i += 1) { byte b = EncBuffer[i]; if (b != 10) { buf.Add(b); } } }
public void Add(TT item) { LocalList.Add(item); _dataSource.AddToList(Name, item); }
private short XMin, XMax, YMin, YMax; // These are calculated by GetFontBytes. private byte[] GetFontBytes() // Returns the TrueType subset file as an array of bytes. { /* Tables required in theory ( those marked '?' may not actually be needed in PDF, maxp IS needed ). * 'cmap' character to glyph mapping (?) * 'glyf' glyph data * 'head' font header * 'hmtx' horizontal metrics * 'hhea' horizontal header * 'loca' index to location * 'maxp' maximum profile * 'name' naming (?) * 'post' PostScript (?) * 'OS/2' Font validator says this is a required table (?) */ TrueType.Writer tw = new TrueType.Writer(7); // glyf, head, hmtx, hhea, loca, maxp Generic.List <uint> locations = new Generic.List <uint>(); // Summary values for 'head' 'hhea' and 'maxp' tables calculated as 'glyp' table is written. XMin = 0x7fff; XMin = 0x7fff; XMax = -0x8000; YMax = -0x8000; int maxContours = 0, maxPoints = 0, maxComponentPoints = 0, maxComponentContours = 0, maxComponentDepth = 0, maxComponentElements = 0, xMaxExtent = 0, minRightSideBearing = 0x7fff; int advanceWidthMax = -0x8000, minLeftSideBearing = 0x7fff; // 'glyf' table tw.BeginTable(); for (int gi = 0; gi < GList.Count; gi += 1) { int sgi = GList[gi]; TrueType.Glyph g; Inp.ReadGlyph(sgi, false, out g); locations.Add(tw.Offset()); TrueType.WidthInfo w; Inp.GetGlyphWidth(sgi, out w); if (w.AdvanceWidth > advanceWidthMax) { advanceWidthMax = w.AdvanceWidth; } if (w.LeftSideBearing < minLeftSideBearing) { minLeftSideBearing = w.LeftSideBearing; } if (g.XMin < XMin) { XMin = g.XMin; } if (g.YMin < YMin) { YMin = g.YMin; } if (g.XMax > XMax) { XMax = g.XMax; } if (g.YMax > YMax) { YMax = g.YMax; } int extent = w.LeftSideBearing + (g.XMax - g.XMin); if (extent > xMaxExtent) { xMaxExtent = extent; } int rsb = w.AdvanceWidth - w.LeftSideBearing - (g.XMax - g.XMin); if (rsb < minRightSideBearing) { minRightSideBearing = rsb; } if (g.Contours != 0) { if (g.Contours >= 0) { if (g.Contours > maxContours) { maxContours = g.Contours; } if (g.Points > maxPoints) { maxPoints = g.Points; } if (KeepInstructions) { tw.Write(Inp.Data, g.Pos, g.Len); } else { int off = 10 + 2 * g.Contours; /* Contours .. EndPoints */ tw.Write(Inp.Data, g.Pos, off); tw.Put16(0); off += 2 + g.InstructionLen; tw.Write(Inp.Data, g.Pos + off, g.Len - off); } } else // Compound glyph { tw.Write(Inp.Data, g.Pos, 10); for (int i = 0; i < g.Components.Count; i += 1) { TrueType.Component c = g.Components[i]; c.GlyphIx = (uint)XG((int)c.GlyphIx); tw.Put(c); } TrueType.GlyphStats gs; Inp.GetGlyphStats(sgi, out gs); if (gs.Points > maxComponentPoints) { maxComponentPoints = gs.Points; } if (gs.Contours > maxComponentContours) { maxComponentContours = gs.Contours; } if (gs.ComponentDepth > maxComponentDepth) { maxComponentDepth = gs.ComponentDepth; } // Maximum number of components referenced at “top level” for any composite glyph. if (g.Components.Count > maxComponentElements) { maxComponentElements = g.Components.Count; // Not sure what "top level" means, maybe just not recursive calc? } } } tw.Pad(4); } locations.Add(tw.Offset()); // Additional entry so length of final glyph is represented in locations. tw.EndTable(TrueType.Tid.glyf); // 'head' table tw.BeginTable(); tw.Put32(0x00010000); // Version tw.Put32(0); // fontRevision tw.Put32(0); // checkSumAdjustment tw.Put32(0x5F0F3CF5); // magic number tw.Put16(0); // flags tw.Put16(Inp.UnitsPerEm); // unitsPerEm tw.Put64(0); // created tw.Put64(0); // modified unchecked { tw.Put16((ushort)XMin); tw.Put16((ushort)YMin); tw.Put16((ushort)XMax); tw.Put16((ushort)YMax); } tw.Put16(0); // macStyle tw.Put16(7); // lowestRecPPEM tw.Put16(2); // fontDirectionHint tw.Put16(1); // indexToLocFormat tw.Put16(0); // glyphDataFormat tw.EndTable(TrueType.Tid.head); // 'hmtx' horizontal metrics tw.BeginTable(); foreach (int gi in GList) { TrueType.WidthInfo w; Inp.GetGlyphWidth(gi, out w); unchecked { tw.Put16(w.AdvanceWidth); tw.Put16((uint)w.LeftSideBearing); } } tw.EndTable(TrueType.Tid.hmtx); // 'hhea' horizontal header tw.BeginTable(); unchecked { tw.Put32(0x00010000); // Fixed version 0x00010000 (1.0) tw.Put16((uint)YMax); // FWord ascent Distance from baseline of highest ascender tw.Put16((uint)YMin); // FWord descent Distance from baseline of lowest descender tw.Put16(Inp.LineGap); // FWord lineGap typographic line gap tw.Put16((uint)advanceWidthMax); // uFWord advanceWidthMax must be consistent with horizontal metrics tw.Put16((uint)minLeftSideBearing); // FWord minLeftSideBearing must be consistent with horizontal metrics tw.Put16((uint)minRightSideBearing); // FWord minRightSideBearing must be consistent with horizontal metrics tw.Put16((uint)xMaxExtent); // FWord xMaxExtent max(lsb + (xMax-xMin)) tw.Put16(1); // int16 caretSlopeRise used to calculate the slope of the caret (rise/run) set to 1 for vertical caret tw.Put16(0); // int16 caretSlopeRun 0 for vertical tw.Put16(0); // FWord caretOffset set value to 0 for non-slanted fonts tw.Put16(0); // int16 reserved set value to 0 tw.Put16(0); // int16 reserved set value to 0 tw.Put16(0); // int16 reserved set value to 0 tw.Put16(0); // int16 reserved set value to 0 tw.Put16(0); // int16 metricDataFormat 0 for current format tw.Put16((uint)GList.Count); // uint16 numOfLongHorMetrics number of advance widths in metrics table } tw.EndTable(TrueType.Tid.hhea); // 'loca' table ( glyph locations ) tw.BeginTable(); foreach (uint loc in locations) { tw.Put32(loc); } tw.EndTable(TrueType.Tid.loca); // 'maxp' maximum profile table tw.BeginTable(); tw.Put32(0x00010000); // version tw.Put16((uint)GList.Count); // numGlyphs the number of glyphs in the font tw.Put16((uint)maxPoints); // maxPoints points in non-compound glyph tw.Put16((uint)maxContours); // maxContours contours in non-compound glyph tw.Put16((uint)maxComponentPoints); // maxComponentPoints points in compound glyph ( todo ) tw.Put16((uint)maxComponentContours); // maxComponentContours contours in compound glyph ( todo ) tw.Put16(2); // maxZones set to 2 tw.Put16(0); // maxTwilightPoints points used in Twilight Zone (Z0) tw.Put16(0); // maxStorage number of Storage Area locations tw.Put16(0); // maxFunctionDefs number of FDEFs tw.Put16(0); // maxInstructionDefs number of IDEFs tw.Put16(0); // maxStackElements maximum stack depth tw.Put16(0); // maxSizeOfInstructions byte count for glyph instructions tw.Put16((uint)maxComponentElements); // maxComponentElements number of glyphs referenced at top level tw.Put16((uint)maxComponentDepth); // maxComponentDepth levels of recursion, set to 0 if font has only simple glyphs tw.EndTable(TrueType.Tid.maxp); // 'cmap' table : doesn't seem to be needed by PDF ( PDF has own ToUnicode representation ), may be useful when testing. // WriteCmap( tw ); // 'name' naming /* * tw.BeginTable(); * tw.Put16(0); // UInt16 format Format selector. Set to 0. * tw.Put16(0); // UInt16 count The number of nameRecords in this name table. * tw.Put16(0); // UInt16 stringOffset Offset in bytes to the beginning of the name character strings. * // NameRecord nameRecord[count] The name records array. * // variable name character strings The character strings of the names. Note that these are not necessarily ASCII! * tw.EndTable( Tid.name ); */ // 'post' PostScript /* * tw.BeginTable(); * tw.Put32(0x00030000); // Fixed format Format of this table * tw.Put32(0); // Fixed italicAngle Italic angle in degrees * tw.Put16(0); // FWord underlinePosition Underline position * tw.Put16(0); // FWord underlineThickness Underline thickness * tw.Put32(0); // uint32 isFixedPitch Font is monospaced; set to 1 if the font is monospaced and 0 otherwise (N.B., to maintain compatibility with older versions of the TrueType spec, accept any non-zero value as meaning that the font is monospaced) * tw.Put32(0); // uint32 minMemType42 Minimum memory usage when a TrueType font is downloaded as a Type 42 font * tw.Put32(0); // uint32 maxMemType42 Maximum memory usage when a TrueType font is downloaded as a Type 42 font * tw.Put32(0); // uint32 minMemType1 Minimum memory usage when a TrueType font is downloaded as a Type 1 font * tw.Put32(0); // uint32 maxMemType1 Maximum memory usage when a TrueType font is downloaded as a Type 1 font * tw.EndTable( Tid.post ); */ tw.Finish(); byte [] result = tw.ToArray(); // Util.WriteFile( "test.ttf", result ); // ( for debugging ) return(result); }
public void ReadGlyph(int gi, bool getPoints, out Glyph g) { GotoTable(Tid.loca); uint offset, next; if (IndexToLocFormat == 0) { Ix += (uint)gi * 2; offset = 2 * Get16(); next = 2 * Get16(); } // Note the offsets are multiplied by 2 in the short format! else { Ix += (uint)gi * 4; offset = Get32(); next = Get32(); } g = new Glyph(); if (next == offset) { g.Contours = 0; g.Len = 0; } // Empty glyph ( space ) else { GotoTable(Tid.glyf); IxLimit = Ix + next; Ix += offset; g.Pos = (int)Ix; g.Contours = GetI16(); g.XMin = (short)GetI16(); g.YMin = (short)GetI16(); g.XMax = (short)GetI16(); g.YMax = (short)GetI16(); if (g.Contours >= 0) // Simple glyph { ushort [] endPtsOfContours = new ushort[g.Contours]; // Shouldn't allocate this is !getPoints, but currently used to calculate # points. uint points = 0; if (getPoints) { for (int i = 0; i < g.Contours; i += 1) { uint ep = Get16(); endPtsOfContours[i] = (ushort)ep; } g.EndPoints = endPtsOfContours; points = (uint)g.EndPoints[g.Contours - 1] + 1; } else { Ix += (uint)(2 * (g.Contours - 1)); points = 1 + Get16(); } g.Points = (ushort)points; uint instructionLength = Get16(); g.InstructionLen = (int)instructionLength; if (!getPoints) // Usually we don't need to parse the points. { Ix = IxLimit; } else { Ix += instructionLength; byte [] flags = new byte[points]; byte flag = 0, rep = 0; for (int i = 0; i < points; i += 1) { if (rep > 0) { rep -= 1; } else { flag = Get8(); if ((flag & 8) != 0) { rep = Get8(); } } flags[i] = flag; } short [] xs = new short[points]; int x = 0; for (int i = 0; i < points; i += 1) { flag = flags[i]; if ((flag & 2) != 0) { byte b = Get8(); if ((flag & 16) != 0) { x += b; } else { x -= b; } } else if ((flag & 16) == 0) { x += GetI16(); } xs[i] = (short)x; } short [] ys = new short[points]; int y = 0; for (int i = 0; i < points; i += 1) { flag = flags[i]; if ((flag & 4) != 0) { byte b = Get8(); if ((flag & 32) != 0) { y += b; } else { y -= b; } } else if ((flag & 32) == 0) { y += GetI16(); } ys[i] = (short)y; } g.Flags = flags; g.X = xs; g.Y = ys; } } else // Compound glyph { Generic.List <Component> components = new Generic.List <Component>(); while (1 == 1) { uint flags = Get16(); uint glyphIndex = Get16(); uint a1, a2, s1 = 0, s2 = 0, s3 = 0, s4 = 0; if ((flags & 1) != 0) { a1 = Get16(); a2 = Get16(); } else { a1 = Get8(); a2 = Get8(); } if ((flags & 8) != 0) { s1 = Get16(); } else if ((flags & 0x40) != 0) { s1 = Get16(); s2 = Get16(); } else if ((flags & 0x80) != 0) { s1 = Get16(); s2 = Get16(); s3 = Get16(); s4 = Get16(); } Component nc; nc.GlyphIx = glyphIndex; nc.Flags = flags; nc.A1 = a1; nc.A2 = a2; nc.S1 = s1; nc.S2 = s2; nc.S3 = s3; nc.S4 = s4; components.Add(nc); if ((flags & 0x20) == 0) { break; } } g.Components = components; } g.Len = (int)(Ix - g.Pos); } }
internal static ComprehensionIterator[] RevertComprehensions(PythonList comprehensions) { Generic.List<ComprehensionIterator> comprehensionIterators = new Generic.List<ComprehensionIterator>(); foreach (comprehension comp in comprehensions) { ComprehensionFor cf = new ComprehensionFor(expr.Revert(comp.target), expr.Revert(comp.iter)); comprehensionIterators.Add(cf); foreach (expr ifs in comp.ifs) { comprehensionIterators.Add(new ComprehensionIf(expr.Revert(ifs))); } } return comprehensionIterators.ToArray(); }
internal static PythonList Convert(ComprehensionIterator[] iters) { Generic.List<ComprehensionFor> cfCollector = new Generic.List<ComprehensionFor>(); Generic.List<Generic.List<ComprehensionIf>> cifCollector = new Generic.List<Generic.List<ComprehensionIf>>(); Generic.List<ComprehensionIf> cif = null; for (int i = 0; i < iters.Length; i++) { if (iters[i] is ComprehensionFor) { ComprehensionFor cf = (ComprehensionFor)iters[i]; cfCollector.Add(cf); cif = new Generic.List<ComprehensionIf>(); cifCollector.Add(cif); } else { ComprehensionIf ci = (ComprehensionIf)iters[i]; cif.Add(ci); } } PythonList comps = new PythonList(); for (int i = 0; i < cfCollector.Count; i++) comps.Add(new comprehension(cfCollector[i], cifCollector[i].ToArray())); return comps; }