public void It_should_not_blow_up_when_it_gets_junk_input() { ConversionExtensions.CalculateLeanKitPriority("Roscoe").ShouldEqual(1); ConversionExtensions.CalculateLeanKitPriority("40").ShouldEqual(1); ConversionExtensions.CalculateLeanKitPriority("0").ShouldEqual(1); ConversionExtensions.CalculateLeanKitPriority("6").ShouldEqual(1); }
private WndWindowStateConfiguration( WndWindowDefinition wndWindow, ColorRgba textColor, ColorRgba textBorderColor, WndDrawData wndDrawData, StretchableImage image, GraphicsDevice graphicsDevice, GraphicsDevice2D graphicsDevice2D) { TextColor = textColor; TextBorderColor = textBorderColor; if (!wndWindow.Status.HasFlag(WndWindowStatusFlags.Image)) { BackgroundColor = ConversionExtensions.ToColorRgbaF(wndDrawData.Items[0].Color); } if (BackgroundColor != null || wndWindow.Status.HasFlag(WndWindowStatusFlags.Border)) { BorderColor = ConversionExtensions.ToColorRgbaF(wndDrawData.Items[0].BorderColor); } if (image != null) { ImageTexture = AddDisposable(image.RenderToTexture(graphicsDevice, graphicsDevice2D)); } }
/// <summary> /// set up values from constructor and intialize global value /// </summary> /// <param name="steps">sequence of the different steps of multi-step predictions to learn</param> /// <param name="alpha">The alpha used to compute running averages of the bucket duty ///cycles for each activation pattern bit.A lower alpha results ///in longer term memory.</param> /// <param name="actValueAlpha"></param> private void Initialize(IList <int> steps, double alpha, double actValueAlpha) { this.steps = steps; this.alpha = alpha; this.actValueAlpha = actValueAlpha; //for null value add -1 instead of 0 actualValues.Add(IsNumericType(default(T)) ? ConversionExtensions.Convert <T>(-1) : default(T)); }
private static void RegisterCustomTypeHandlers() { ConversionExtensions.RegisterCustomTypeConverter(typeof(TMP_FontAsset), (value, xmlLayout) => { var font = XmlLayoutUtilities.LoadResource <TMP_FontAsset>(value); if (font == null) { Debug.LogWarning("[XmlLayout][TextMesh Pro] Unable to load TMP Font Asset '" + value + "'."); } return(font); }); ConversionExtensions.RegisterCustomTypeConverter(typeof(TMPro.FontStyles), (value) => { var stylesEntries = value.Split('|'); FontStyles styles = FontStyles.Normal; foreach (var style in stylesEntries) { try { FontStyles s = (FontStyles)Enum.Parse(typeof(FontStyles), style); styles |= s; } catch { } } return(styles); }); ConversionExtensions.RegisterCustomTypeConverter(typeof(TMPro.VertexGradient), (value, xmlLayout) => { var colorBlock = value.ToColorBlock(xmlLayout); return(new TMPro.VertexGradient(colorBlock.normalColor, colorBlock.highlightedColor, colorBlock.pressedColor, colorBlock.disabledColor)); }); ConversionExtensions.RegisterCustomTypeConverter(typeof(TMPro.TMP_SpriteAsset), (value) => { var spriteAsset = XmlLayoutUtilities.LoadResource <TMP_SpriteAsset>(value); if (spriteAsset == null) { Debug.LogWarning("[XmlLayout][TextMesh Pro] Unable to load TMP Sprite Asset '" + value + "'."); } return(spriteAsset); }); }
private WndWindowStateConfiguration( WndWindowDefinition wndWindow, ColorRgba textColor, ColorRgba textBorderColor, WndDrawData wndDrawData) { TextColor = textColor; TextBorderColor = textBorderColor; if (!wndWindow.Status.HasFlag(WndWindowStatusFlags.Image)) { BackgroundColor = ConversionExtensions.ToColorRgbaF(wndDrawData.Items[0].Color); } if (BackgroundColor != null || wndWindow.Status.HasFlag(WndWindowStatusFlags.Border)) { BorderColor = ConversionExtensions.ToColorRgbaF(wndDrawData.Items[0].BorderColor); } }
public static List <Boerman.OpenAip.Airport> Parse(TextReader contents) { XmlSerializer serializer = new XmlSerializer(typeof(Intermediate.AirportIntermediate.OPENAIP)); var intermediate = serializer.Deserialize(contents) as Intermediate.AirportIntermediate.OPENAIP; var list = intermediate?.Waypoints.Airport.Select(x => new Boerman.OpenAip.Airport { Country = x.Country, ICAO = x.ICAO, Location = new Point( Convert.ToDouble(x.Geolocation.Longitude), Convert.ToDouble(x.Geolocation.Langitude), Convert.ToDouble(x.Geolocation.Elevation.Value)), Name = x.Name, Type = ConversionExtensions.Parse(x.Type, AirportType.AD_CLOSED), Radios = x.Radio?.Select(r => new Radio { Category = ConversionExtensions.Parse(r.Category, RadioCategory.OHER), Type = ConversionExtensions.Parse(r.Type, RadioType.OTHER), Description = r.Description, Frequency = r.Frequency, TypeSpecification = r.TypeSpecification }).ToArray(), Runways = x.Runways?.Select(rw => new Runway { Name = rw.Name, Surface = ConversionExtensions.Parse(rw.Surface, SurfaceType.UNKN), Length = Convert.ToDecimal(rw.Length.Value), Width = Convert.ToDecimal(rw.Width.Value), Strength = rw.Strength != null ? (ConversionExtensions.Parse(rw.Strength.Unit, StrengthType.PCN), rw.Strength.Value) : ((StrengthType, string Value)?)null, Operations = rw.Operations, Directions = rw.Direction.Select(rwd => new RunwayDirection { LDA = ConversionExtensions.ToNullableDecimal(rwd.Runs.LDA?.Value) ?? -1, ILS = rwd.LandingAids?.ILS ?? -1, PAPI = ConversionExtensions.ToNullableBoolean(rwd.LandingAids?.PAPI) ?? false, TC = Convert.ToInt32(rwd.TC), TORA = ConversionExtensions.ToNullableDecimal(rwd.Runs?.TORA.Value) ?? -1 }).ToArray() }).ToArray()
public void It_should_return_default_card_type_if_issue_has_no_matching_priority() { ConversionExtensions.CalculateLeanKitCardType(_mapping, "Bob").Id.ShouldEqual(_testBoard.CardTypes.Last().Id); }
public void It_should_map_priority_of_2_to_high() { ConversionExtensions.CalculateLeanKitPriority("2").ShouldEqual(2); }
public void It_should_map_priority_of_4_to_low() { ConversionExtensions.CalculateLeanKitPriority("4").ShouldEqual(0); }
/// <summary> /// Method computes the result after the data is provided by the temporal memory and encoder /// </summary> /// <param name="recordNum">Record number of this input pattern. /// Record numbers should normally increase sequentially by 1 each time unless there are missing records in the dataset. /// Knowing this information insures that we don't get confused by missing records.</param> /// <param name="classification">{@link Map} of the classification information: /// bucketIdx: index of the encoder bucket</param> /// <param name="patternNZ">list of the active indices from the output below</param> /// <param name="learn">if true, learn this sample</param> /// <param name="infer">if true, perform inference</param> /// <returns>ClassificationExperiment Object</returns> public ClassificationExperiment <T> Compute(int recordNum, Dictionary <string, object> classification, int[] patternNZ, bool learn, bool infer) { if (classification == null) { throw new ArgumentNullException(nameof(classification)); } if (patternNZ == null) { throw new ArgumentNullException(nameof(patternNZ)); } ClassificationExperiment <T> retVal = new ClassificationExperiment <T>(); List <T> actualValues = (List <T>) this.actualValues; // Save the offset between recordNum and learnIteration if this is the first // compute if (recordNumMinusLearnIteration == -1) { recordNumMinusLearnIteration = recordNum - learnIteration; } // Update the learn iteration learnIteration = recordNum - recordNumMinusLearnIteration; if (patternNZHistory.Any(x => x.Item1 == learnIteration)) { patternNZHistory.Add(Tuple.Create(learnIteration, patternNZ)); } //------------------------------------------------------------- // For each active bit in the activationPattern, get the classification // votes // // Return value dict. For buckets which we don't have an actual value // for yet, just plug in any valid actual value. It doesn't matter what // we use because that bucket won't have non-zero likelihood anyways. if (infer) { // If doing 0-step prediction, we shouldn't use any knowledge // of the classification input during inference. object defaultValue = default(T); if (steps[0] == 0) { defaultValue = 0; } else { defaultValue = classification["actValue"]; if (defaultValue == null) { if (IsNumericType(default(T))) { defaultValue = ConversionExtensions.Convert <T>(-1); } } } T[] actValues = new T[this.actualValues.Count]; for (int i = 0; i < actualValues.Count; i++) { if (IsNumericType(default(T))) { actValues[i] = (T)(actualValues[i].Equals(ConversionExtensions.Convert <T>(-1)) ? ConversionExtensions.Convert <T>(defaultValue) : actualValues[i]); } else { actValues[i] = (T)(actualValues[i].Equals(default(T)) ? defaultValue : actualValues[i]); } } retVal.setActualValues(actValues); // For each n-step prediction... foreach (int nSteps in steps) { // Accumulate bucket index votes and actValues into these arrays double[] sumVotes = new double[maxBucketIdx + 1]; double[] bitVotes = new double[maxBucketIdx + 1]; foreach (var bit in patternNZ) { var key = Tuple.Create(bit, nSteps); BitHistory history = null; activeBitHistory.TryGetValue(key, out history); if (history == null) { continue; } history.Infer(bitVotes); sumVotes = ArrayUtils.AddOffset(sumVotes, bitVotes); } // Return the votes for each bucket, normalized double total = sumVotes.Sum(); if (total > 0) { sumVotes = ArrayUtils.Divide(sumVotes, total); } else { // If all buckets have zero probability then simply make all of the // buckets equally likely. There is no actual prediction for this // timestep so any of the possible predictions are just as good. if (sumVotes.Length > 0) { double val = 1.0 / sumVotes.Length; for (int i = 0; i < sumVotes.Length; i++) { sumVotes[i] = val; } } } retVal.setStats(nSteps, sumVotes); } } // ------------------------------------------------------------------------ // Learning: // For each active bit in the activationPattern, store the classification // info. If the bucketIdx is None, we can't learn. This can happen when the // field is missing in a specific record. if (learn && classification["bucketIdx"] != null) { // Get classification info int bucketIdx = (int)classification["bucketIdx"]; object actValue = null; if (classification["actValue"] == null) { if (IsNumericType(default(T))) { actValue = ConversionExtensions.Convert <T>(-1); } } else { actValue = ConversionExtensions.Convert <T>(classification["actValue"]); } // Update maxBucketIndex maxBucketIdx = (int)Math.Max(maxBucketIdx, bucketIdx); // Update rolling average of actual values if it's a scalar. If it's // not, it must be a category, in which case each bucket only ever // sees one category so we don't need a running average. while (maxBucketIdx > actualValues.Count - 1) { actualValues.Add(IsNumericType(default(T)) ? ConversionExtensions.Convert <T>(-1) : default(T)); } if (actualValues[bucketIdx].Equals(IsNumericType(default(T)) ? ConversionExtensions.Convert <T>(-1) : default(T))) { actualValues[bucketIdx] = (T)actValue; } else { if (IsNumericType(actValue)) { double val = ((1.0 - actValueAlpha) * Convert.ToDouble(actualValues[bucketIdx], enusFormatProvider)) + (actValueAlpha * (Convert.ToDouble(actValue, enusFormatProvider))); actualValues[bucketIdx] = ConversionExtensions.Convert <T>(val); } else { actualValues[bucketIdx] = (T)actValue; } } // Train each pattern that we have in our history that aligns with the // steps we have in steps int nSteps = -1; int iteration = 0; int[] learnPatternNZ = null; foreach (var n in steps) { nSteps = n; // Do we have the pattern that should be assigned to this classification // in our pattern history? If not, skip it bool found = false; foreach (var t in patternNZHistory) { iteration = t.Item1; learnPatternNZ = t.Item2; if (iteration == learnIteration - nSteps) { found = true; break; } iteration++; } if (!found) { continue; } // Store classification info for each active bit from the pattern // that we got nSteps time steps ago. foreach (int bit in learnPatternNZ) { // Get the history structure for this bit and step var key = Tuple.Create(bit, nSteps); BitHistory history = null; activeBitHistory.TryGetValue(key, out history); if (history == null) { history = new BitHistory(alpha); activeBitHistory.Add(key, history); } history.store(learnIteration, bucketIdx); } } } return(retVal); }
/// <summary> /// Load data from 'itemData' and apply it to 'element' /// (Also iterates recursively through all child elements) /// </summary> /// <param name="element">Element to apply the data to</param> /// <param name="itemData">Object containing the data to use</param> /// <param name="dataSource">Required to locate the relevant properties e.g. {dataSource.someProperty}</param> /// <param name="elementTemplate">Used to determine which attribute(s) to replace with data from 'itemData'</param> internal void ApplyViewModelData(XmlElement element, object itemData, string dataSource, XmlElement elementTemplate, IObservableList list, string changedField = null, bool isTopLevel = true, bool isFirstCall = false) { // Iterate through the children first for (var x = 0; x < element.childElements.Count; x++) { var child = element.childElements[x]; ApplyViewModelData(child, itemData, dataSource, elementTemplate.childElements[x], list, changedField, false, isFirstCall); } List <ListItemAttributeMatch> attributesMatched = new List <ListItemAttributeMatch>(); // Get a list of potential attributes to replace with data var attributesToCheck = elementTemplate.attributes.Where(a => a.Value.StartsWith("{") && a.Value.EndsWith("}")) .ToDictionary(k => k.Key, v => v.Value.Replace("{", string.Empty).Replace("}", string.Empty)); if (attributesToCheck.Count > 0) { // Get a list of all fields and properties provided by the ViewModel object var members = itemData.GetType() .GetMembers() .Where(m => { return(changedField == null || // If no specific changed field was provided, pull all members m.Name == changedField || // otherwise, pull the changed field (m is PropertyInfo && !((PropertyInfo)m).IsAutoProperty())); // as well as all non-auto generated properties (e.g. properties other than { get; set; }) }) .Where(m => m is PropertyInfo || m is FieldInfo) .ToList(); // intersect the fields/attributes var fieldsToApply = members.Where(m => attributesToCheck.Values.ToList().Any(a => a.StripChars('?') == (dataSource + "." + m.Name))).ToList(); // Get the data from each field/property, and set the attribute on the element foreach (var field in fieldsToApply) { var attribute = attributesToCheck.FirstOrDefault(a => a.Value.StripChars('?') == dataSource + "." + field.Name); var value = ConversionExtensions.ToString(((field is PropertyInfo ? ((PropertyInfo)field).GetValue(itemData, null) : ((FieldInfo)field).GetValue(itemData)) ?? string.Empty)); element.SetAttribute(attribute.Key, value); attributesMatched.Add(new ListItemAttributeMatch { attribute = attribute.Key, field = field.Name, bindingType = attribute.Value.StartsWith("?") ? ViewModelBindingType.OneWay : ViewModelBindingType.TwoWay }); } } // Apply the attributes (if necessary) if (isFirstCall || attributesMatched.Count > 0) { element.ApplyAttributes(element.attributes.Clone()); } var listItemComponent = element.GetComponent <XmlLayoutListItem>(); if (listItemComponent != null && currentListElement != null) { if (isTopLevel) { HandleListItemPositioning(listItemComponent); } } if (attributesMatched.Count > 0) { HandleTwoWayBinding(element, dataSource, list, itemData, attributesMatched); } }
// allows LayoutCopyService to copy node positions inside collapsed subgraphs protected void CopySavedBoundsFrom(IContainerNode otherContainer) { try { var otherSubGraph = otherContainer as GoSubGraph; if (otherSubGraph == null) { return; } // build Cache of GoNode children ICache <string, GoNode> childNodes = new Cache <string, GoNode>(x => x.Text); //Text = Name foreach (GoNode childNode in Enumerable.Where <GoObject>(this, child => ConversionExtensions.IsAnImplementationOf <GoNode>(child))) { if (!String.IsNullOrEmpty(childNode.Text)) { addUnique(childNodes, childNode.Text, childNode); } else if (childNode.IsAnImplementationOf <INeighborhoodNode>()) //childNode.Text is empty and childNode is NeighborhoodNode { addUnique(childNodes, ((INeighborhoodNode)childNode).Name, childNode); } } // store SavedBounds for each child GoNode with the same name foreach (GoNode otherNode in otherSubGraph.SavedBounds.Keys.Where(child => child.IsAnImplementationOf <GoNode>())) { string name = otherNode.Text; if (String.IsNullOrEmpty(name) && otherNode.IsAnImplementationOf <INeighborhoodNode>()) { name = ((INeighborhoodNode)otherNode).Name; } if (!String.IsNullOrEmpty(name) && childNodes.Contains(name)) { var childNode = childNodes[name]; if (SavedBounds.ContainsKey(childNode)) { SavedBounds[childNode] = otherSubGraph.SavedBounds[otherNode]; } else { SavedBounds.Add(childNode, otherSubGraph.SavedBounds[otherNode]); } } } } catch (Exception ex) { Console.WriteLine(ex.Message + "\n" + ex.StackTrace); } }
private void addChildren <TList, T>(ContainerNodeBase containerBaseNode, IList <TList> children, bool recursive) where T : class, TList { foreach (GoObject child in Enumerable.Where <GoObject>(containerBaseNode, child => ConversionExtensions.IsAnImplementationOf <T>(child))) { addUnique(children, child as T); } if (recursive) { foreach (GoObject child in Enumerable.Where <GoObject>(containerBaseNode, child => ConversionExtensions.IsAnImplementationOf <ContainerNodeBase>(child))) { addChildren <TList, T>(child as ContainerNodeBase, children, recursive); } } }
public static TypeConverter GetTypeConverter(Type type) { return(ConversionExtensions.GetTypeConverter(type)); }
public void It_should_return_mapped_card_type_if_issue_has_matching_label() { ConversionExtensions.CalculateLeanKitCardType(_mapping, "Roger") .Id.ShouldEqual(_testBoard.CardTypes.FirstOrDefault(x => x.Name == "Willy").Id); }
public void It_should_default_to_normal() { ConversionExtensions.CalculateLeanKitPriority(null).ShouldEqual(1); ConversionExtensions.CalculateLeanKitPriority("").ShouldEqual(1); }
protected override IEnumerable <BosuHitObject> ConvertHitObject(HitObject obj, IBeatmap beatmap, CancellationToken cancellationToken) { List <BosuHitObject> hitObjects = new List <BosuHitObject>(); var originalPosition = (obj as IHasPosition)?.Position ?? Vector2.Zero; var comboData = obj as IHasCombo; bool newCombo = comboData?.NewCombo ?? false; if (newCombo) { index = 0; } else { index++; } switch (obj) { case IHasPathWithRepeats curve: double spanDuration = curve.Duration / (curve.RepeatCount + 1); bool isBuzz = spanDuration < 75 && curve.RepeatCount > 0; hitObjects.AddRange(ConversionExtensions.GenerateSliderBody(obj.StartTime, curve, originalPosition)); if (isBuzz) { hitObjects.AddRange(ConversionExtensions.ConvertBuzzSlider(obj, originalPosition, beatmap, curve, spanDuration)); } else { hitObjects.AddRange(ConversionExtensions.ConvertDefaultSlider(obj, originalPosition, beatmap, curve, spanDuration)); } break; case IHasDuration endTime: hitObjects.AddRange(ConversionExtensions.ConvertSpinner(obj.StartTime, endTime, beatmap.ControlPointInfo.TimingPointAt(obj.StartTime).BeatLength)); break; default: if (newCombo) { hitObjects.AddRange(ConversionExtensions.ConvertImpactCircle(obj.StartTime, originalPosition)); } else { hitObjects.AddRange(ConversionExtensions.ConvertDefaultCircle(obj.StartTime, originalPosition, index)); } break; } bool first = true; foreach (var h in hitObjects) { if (h is Cherry c) { c.NewCombo = first && newCombo; c.ComboOffset = comboData?.ComboOffset ?? 0; } if (first) { first = false; } } return(hitObjects); }
public void It_should_map_priority_of_3_to_normal() { ConversionExtensions.CalculateLeanKitPriority("3").ShouldEqual(1); }
public TypeConversionTests() { ConversionExtensions.RegisterAllCustomTypeConverters(); }
public void It_should_map_priority_of_1_to_critical() { ConversionExtensions.CalculateLeanKitPriority("1").ShouldEqual(3); }
public RavenQueryBuilder(ILoggerFactory loggerFactory) { _loggerFactory = loggerFactory; //TODO: Better logging and IOC handling ConversionExtensions.Add(new StringConversionExtensions(_loggerFactory.CreateLogger <StringConversionExtensions>())); }