public BackendlessGeoQuery( double NWLat, double NWLon, double SELat, double SWLon, Units units, List<string> categories ) { ClusterGridSize = CLUSTER_SIZE_DEFAULT_VALUE; SearchRectangle = new[] { NWLat, NWLon, SELat, SWLon }; Units = units; Categories = categories; }
// Methods internal LinearGradient(string prefix, string localname, string ns, SvgDocument doc) : base(prefix, localname, ns, doc) { this.x1 = 0f; this.y1 = 0f; this.x2 = 1f; this.y2 = 0f; this.gradientTransform = new Transf(); this.gradientUnit = Units.ObjectBoundingBox; this.spreadMethod = SpreadMethods.Pad; this.boundsPath = new GraphicsPath(); this.boundrect = RectangleF.Empty; this.stops = new SvgElementCollection(); this.gradientstart = PointF.Empty; this.gradientend = PointF.Empty; this.rotatepoint = PointF.Empty; this.translatepoint = PointF.Empty; this.scalePoint = PointF.Empty; this.boundsPoints = new PointF[0]; this.ratiomatrix = new Matrix(); this.brush = null; this.coord = new Matrix(); this.gradientpath = new GraphicsPath(); this.pen = null; this.GraphMatrix = new Matrix(); }
public UnitsResponse Post(Units request) { if (request.Unit.Id > 0) { Bm2s.Data.Common.BLL.Parameter.Unit item = Datas.Instance.DataStorage.Units[request.Unit.Id]; item.Code = request.Unit.Code; item.Description = request.Unit.Description; item.EndingDate = request.Unit.EndingDate; item.IsCurrency = request.Unit.IsCurrency; item.IsPeriod = request.Unit.IsPeriod; item.Name = request.Unit.Name; item.StartingDate = request.Unit.StartingDate; Datas.Instance.DataStorage.Units[request.Unit.Id] = item; } else { Bm2s.Data.Common.BLL.Parameter.Unit item = new Data.Common.BLL.Parameter.Unit() { Code = request.Unit.Code, Description = request.Unit.Description, EndingDate = request.Unit.EndingDate, IsCurrency = request.Unit.IsCurrency, IsPeriod = request.Unit.IsPeriod, Name = request.Unit.Name, StartingDate = request.Unit.StartingDate }; Datas.Instance.DataStorage.Units.Add(item); request.Unit.Id = item.Id; } UnitsResponse response = new UnitsResponse(); response.Units.Add(request.Unit); return response; }
public int GetDistance(Address origin, Address destination, Mode mode, Units units) { if (origin == null || destination == null) { return 0; } var request = (HttpWebRequest) WebRequest.Create( new Uri(String.Format(DistanceMatrixUrl, new object[] { HttpUtility.JavaScriptStringEncode(origin.PostalCode), HttpUtility.JavaScriptStringEncode(destination.PostalCode), Enum.GetName(typeof(Mode), mode), Enum.GetName(typeof(Units), units) }))); var response = (HttpWebResponse) request.GetResponse(); if (response.StatusCode != HttpStatusCode.OK) return 0; using (var streamReader = new StreamReader(response.GetResponseStream())) { var result = streamReader.ReadToEnd(); if (string.IsNullOrEmpty(result)) return 0; var jsonObject = JObject.Parse(result); var distance = (int)jsonObject.SelectToken("rows[0].elements[0].distance.value"); return distance / 1000; } }
/// <summary> /// Променя стойност в речника stats по зададените параметри /// </summary> /// <param name="unitToSet">В каква мерна единица е зададеното число</param> /// <param name="value">Самото число което задаваме</param> public void SetStat(Units unitToSet, double value) { foreach (Units unit in UnitS.Array) { stats[unit].Value = value * (stats[unitToSet].Modifier / stats[unit].Modifier); } }
public override void PlaceBuilding(Units.Engineer e) { this.state = State.Constructing; this.constructedBy = e; e.constructing = this; this.mesh = Game1.GetInstance().map.collisionMap.PlaceBuilding(this.DefineRectangle()); Game1.GetInstance().IsMouseVisible = true; for( int i = 0; i < p.buildings.Count(); i++){ Building b = p.buildings.ElementAt(i); if (b != this) { if (b.type != Type.Resources && b.type != Type.Sentry) { if (b.waypoints.Count() > 0) { Point point = b.waypoints.GetLast(); PathfindingProcessor.GetInstance().Push(b, point); } } } } if (Game1.GetInstance().IsMultiplayerGame() && this.p == Game1.CURRENT_PLAYER) { Synchronizer.GetInstance().QueueBuilding(this); } p.resources -= Building.GetCost(this.type); }
public virtual void OnUnitDead(Units unitDead) { if (inRangeUnits.Contains(unitDead)) { inRangeUnits.Remove(unitDead); } }
public BackendlessGeoQuery(double latitude, double longitude, double radius, Units units) { Latitude = latitude; Longitude = longitude; Radius = radius; Units = units; PageSize = 100; }
public SlamEffect(Units.MainCharacter performer) { AddChild(new SwordStrikeEffect(performer, 0.3f, 0.47f, new TextureFromFile("Models/Effects/SlamFire1.png"), -10f) { OrientationRelation = OrientationRelation.Absolute }); }
public AreaSettings(Units units, float top, float left, float bottom, float right) { _units = units; _top = top; _left = left; _bottom = bottom; _right = right; }
/// <summary> /// Builds marble geometry /// </summary> private void BuildGeometry( Units.Metres radius ) { DestroyGeometry( ); Graphics.Draw.StartCache( ); Graphics.Draw.Sphere( null, Point3.Origin, ( float )radius.ToAstroRenderUnits, 20, 20 ); m_Geometry = Graphics.Draw.StopCache( ); m_GeometryRadius = radius; }
public static Amount Convert(Amount amount, Units toUnit) { var ret = new Amount(); ret.Unit = toUnit; ret.SizeLow = amount.SizeLow.HasValue ? (float?)Convert(amount.SizeLow.Value, amount.Unit, toUnit) : null; ret.SizeHigh = Convert(amount.SizeHigh, amount.Unit, toUnit); return ret; }
public UnitsResponse Delete(Units request) { Bm2s.Data.Common.BLL.Parameter.Unit item = Datas.Instance.DataStorage.Units[request.Unit.Id]; item.EndingDate = DateTime.Now; Datas.Instance.DataStorage.Units[item.Id] = item; UnitsResponse response = new UnitsResponse(); response.Units.Add(request.Unit); return response; }
public IngredientForm(Guid formId, Guid ingredientId, Units unitType, string displayName, string unitName, int conversionMultiplier, Amount amount) { this.FormId = formId; this.IngredientId = ingredientId; this.FormUnitType = unitType; this.FormDisplayName = displayName; this.FormUnitName = unitName; this.ConversionMultiplier = conversionMultiplier; this.FormAmount = amount; }
public IngredientForm(Guid formid, Guid ingredientid, Units unittype, string displayname, string unitname, int convmultiplier, Amount amount) { FormId = formid; IngredientId = ingredientid; FormUnitType = unittype; FormDisplayName = displayname; FormUnitName = unitname; ConversionMultiplier = convmultiplier; FormAmount = amount; }
public double continuousRotation(double x, Units unit, string indexer) { if(!continousRotationStrategies.ContainsKey(indexer)) continousRotationStrategies[indexer] = new ContinuesRotationStrategy(unit); var strategy = continousRotationStrategies[indexer]; strategy.Update(x); return strategy.Out; }
public BackendlessGeoQuery(double latitude, double longitude, double radius, Units units, List<string> categories) { Latitude = latitude; Longitude = longitude; Radius = radius; Units = units; Categories = categories; PageSize = 100; }
/// <summary> /// Calculate the distance between two places. /// </summary> /// <param name="lat1"></param> /// <param name="lon1"></param> /// <param name="lat2"></param> /// <param name="lon2"></param> /// <param name="unit"></param> /// <returns></returns> public static double DistanceBetweenPlaces(double lat1, double lon1, double lat2, double lon2, Units unit) { double dlon = Radians(lon2 - lon1); double dlat = Radians(lat2 - lat1); double a = (Math.Sin(dlat / 2) * Math.Sin(dlat / 2)) + Math.Cos(Radians(lat1)) * Math.Cos(Radians(lat2)) * (Math.Sin(dlon / 2) * Math.Sin(dlon / 2)); double angle = 2 * Math.Atan2(Math.Sqrt(a), Math.Sqrt(1 - a)); double distance = (angle * RADIO) * (unit == Units.Miles ? 0.62137 : 1); return distance; }
public double ToKG(double value, Units unit) { switch (unit) { case Units.T: return value * 1000; default: throw new Exception("Uncorrect cast to SI"); } }
public double ToSec(double value, Units unit) { switch (unit) { case Units.Day: return value * 60 * 60 * 24; default: throw new Exception("Uncorrect cast to SI"); } }
public static IngredientBinding Create(Guid ingId, Guid recipeId, Single? qty, Units usageUnit, UnitType convType, Int32 unitWeight, Units formUnit, Single equivAmount, Units equivUnit) { var rawUnit = KitchenPC.Unit.GetDefaultUnitType(convType); if (qty.HasValue && rawUnit != usageUnit) { if (UnitConverter.CanConvert(usageUnit, rawUnit)) { qty = UnitConverter.Convert(qty.Value, usageUnit, rawUnit); } else { var ing = new Ingredient { Id = ingId, ConversionType = convType, UnitWeight = unitWeight }; var form = new IngredientForm { FormUnitType = formUnit, FormAmount = new Amount(equivAmount, equivUnit), IngredientId = ingId }; var usage = new Ingredients.IngredientUsage { Form = form, Ingredient = ing, Amount = new Amount(qty.Value, usageUnit) }; try { var newAmt = FormConversion.GetNativeAmountForUsage(ing, usage); qty = UnitConverter.Convert(newAmt.SizeHigh, newAmt.Unit, rawUnit); //Ingredient graph only stores high amounts } catch (Exception e) { throw new DataLoadException(e); } } } return new IngredientBinding { RecipeId = recipeId, IngredientId = ingId, Qty = qty.HasValue ? (float?) Math.Round(qty.Value, 3) : null, Unit = rawUnit }; }
/// <summary> /// Sets the value and units of the angle. /// </summary> /// <param name="angularValue">The value for the angle.</param> /// <param name="angularUnits">The units for the angle.</param> public void setAngle(double angularValue, Units.Angular angularUnits) { if (angularUnits == Units.Angular.Radians) { _angularValue = angularValue * radToDeg; } else { _angularValue = angularValue; } }
public static Single Convert(Single amount, Units fromUnit, Units toUnit) { if (fromUnit == toUnit) return amount; if (ConversionMatrix[(int) toUnit, (int) fromUnit] == -1) throw new ArgumentException("Cannot convert from unit " + Unit.GetSingular(fromUnit) + " to unit " + Unit.GetSingular(toUnit)); var coefficient = ConversionMatrix[(int) toUnit, (int) fromUnit]; return amount*coefficient; }
private static ValidationResult EhValidateQuantity(Units.DimensionfulQuantity quantity) { string error = null; double val = quantity.AsValueInSIUnits; if (double.IsInfinity(val)) error = "Value must not be infinity"; else if (double.IsNaN(val)) error = "Value must be a valid number"; return error == null ? ValidationResult.ValidResult : new ValidationResult(false, error); }
public UnitsResponse Get(Units request) { UnitsResponse response = new UnitsResponse(); List<Bm2s.Data.Common.BLL.Parameter.Unit> items = new List<Data.Common.BLL.Parameter.Unit>(); if (!request.Ids.Any()) { items.AddRange(Datas.Instance.DataStorage.Units.Where(item => (string.IsNullOrWhiteSpace(request.Code) || item.Code.ToLower().Contains(request.Code.ToLower())) && (string.IsNullOrWhiteSpace(request.Name) || item.Name.ToLower().Contains(request.Name.ToLower())) && (!request.IsCurrency || item.IsCurrency) && (!request.IsPeriod || item.IsPeriod) && (!request.Date.HasValue || (request.Date >= item.StartingDate && (!item.EndingDate.HasValue || request.Date < item.EndingDate.Value))) )); } else { items.AddRange(Datas.Instance.DataStorage.Units.Where(item => request.Ids.Contains(item.Id))); } var collection = (from item in items select new Bm2s.Poco.Common.Parameter.Unit() { Code = item.Code, Description = item.Description, EndingDate = item.EndingDate, Id = item.Id, IsCurrency = item.IsCurrency, IsPeriod = item.IsPeriod, Name = item.Name, StartingDate = item.StartingDate }).AsQueryable().OrderBy(request.Order, !request.DescendingOrder); response.ItemsCount = collection.Count(); if (request.PageSize > 0) { response.Units.AddRange(collection.Skip((request.CurrentPage - 1) * request.PageSize).Take(request.PageSize)); } else { response.Units.AddRange(collection); } try { response.PagesCount = collection.Count() / response.Units.Count + (collection.Count() % response.Units.Count > 0 ? 1 : 0); } catch { response.PagesCount = 1; } return response; }
public double ToM2(double value, Units unit) { switch (unit) { case Units.Mm2: return value / 1000 / 1000; case Units.Sm2: return value / 100 / 100; default: throw new Exception("Uncorrect cast to SI"); } }
public BackendlessGeoQuery( double latitude, double longitude, double radius, Units units, List<string> categories, Dictionary<string, string> metadata ) { ClusterGridSize = CLUSTER_SIZE_DEFAULT_VALUE; Latitude = latitude; Longitude = longitude; Radius = radius; Units = units; Categories = categories; Metadata = metadata; if( metadata != null ) IncludeMeta = true; }
public static Dictionary<string, string> Calculate(int quantity, Units type, int kilo) { var typeQuantityToBit = UnitValuesToBit[Units.Bit] / UnitValuesToBit[type] * quantity; var result = new Dictionary<string, string>(); foreach (var unit in UnitValuesToBit.Keys) { var value = UnitValuesToBit[unit] * typeQuantityToBit * 1000 / kilo; var valueAsString = value.ToString("G6", CultureInfo.InvariantCulture); result.Add(unit.ToString(), valueAsString); } return result; }
public async Task<WeatherRoot> GetWeather(string city, Units units = Units.Imperial) { using (var client = new HttpClient()) { var url = string.Format(WeatherCityUri, city, units.ToString().ToLower()); var json = await client.GetStringAsync(url); if (string.IsNullOrWhiteSpace(json)) return null; return JsonConvert.DeserializeObject<WeatherRoot>(json); } }
public async Task<WeatherForecastRoot> GetForecast(int id, Units units = Units.Imperial) { using (var client = new HttpClient()) { var url = string.Format(ForecaseUri, id, units.ToString().ToLower()); var json = await client.GetStringAsync(url); if (string.IsNullOrWhiteSpace(json)) return null; return DeserializeObject<WeatherForecastRoot>(json); } }
static BitRate() { BaseDimensions = BaseDimensions.Dimensionless; Info = new QuantityInfo(QuantityType.BitRate, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
static VitaminA() { BaseDimensions = BaseDimensions.Dimensionless; Info = new QuantityInfo(QuantityType.VitaminA, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
public override void Draw(SectionModule section) { this.DrawLine(Units.ToDistance(FlightGlobals.ship_orbit.semiMinorAxis, 3), section.IsHud); }
public static string GetSingular(Units unitType) { return(Singular[(int)unitType]); }
public override async Task <StreamState> SendStream(StreamState state) { var kit = KitManager.GetDefaultKit(); var converter = kit.LoadConverter(Utils.AutocadAppName); converter.SetContextDocument(Doc); var streamId = state.Stream.id; var client = state.Client; if (state.Filter != null) { state.SelectedObjectIds = GetObjectsFromFilter(state.Filter, converter); } // remove deleted object ids var deletedElements = new List <string>(); foreach (var handle in state.SelectedObjectIds) { if (Doc.Database.TryGetObjectId(Utils.GetHandle(handle), out AcadDb.ObjectId id)) { if (id.IsErased || id.IsNull) { deletedElements.Add(handle); } } } state.SelectedObjectIds = state.SelectedObjectIds.Where(o => !deletedElements.Contains(o)).ToList(); if (state.SelectedObjectIds.Count == 0) { RaiseNotification("Zero objects selected; send stopped. Please select some objects, or check that your filter can actually select something."); return(state); } var commitObj = new Base(); var units = Units.GetUnitsFromString(Doc.Database.Insunits.ToString()); commitObj["units"] = units; var conversionProgressDict = new ConcurrentDictionary <string, int>(); conversionProgressDict["Conversion"] = 0; Execute.PostToUIThread(() => state.Progress.Maximum = state.SelectedObjectIds.Count()); int convertedCount = 0; bool renamedlayers = false; foreach (var autocadObjectHandle in state.SelectedObjectIds) { if (state.CancellationTokenSource.Token.IsCancellationRequested) { return(null); } // get the db object from id AcadDb.Handle hn = Utils.GetHandle(autocadObjectHandle); AcadDb.DBObject obj = hn.GetObject(out string type, out string layer); if (obj == null) { state.Errors.Add(new Exception($"Failed to find local object ${autocadObjectHandle}.")); continue; } if (!converter.CanConvertToSpeckle(obj)) { state.Errors.Add(new Exception($"Objects of type ${type} are not supported")); continue; } // convert obj // try catch to prevent memory access violation crash in case a conversion goes wrong Base converted = null; string containerName = string.Empty; try { converted = converter.ConvertToSpeckle(obj); if (converted == null) { state.Errors.Add(new Exception($"Failed to convert object ${autocadObjectHandle} of type ${type}.")); continue; } } catch { state.Errors.Add(new Exception($"Failed to convert object {autocadObjectHandle} of type {type}.")); continue; } /* TODO: adding the extension dictionary / xdata per object * foreach (var key in obj.ExtensionDictionary) * { * converted[key] = obj.ExtensionDictionary.GetUserString(key); * } */ if (obj is BlockReference) { containerName = "Blocks"; } else { // remove invalid chars from layer name string cleanLayerName = Utils.RemoveInvalidDynamicPropChars(layer); containerName = cleanLayerName; if (!cleanLayerName.Equals(layer)) { renamedlayers = true; } } if (commitObj[$"@{containerName}"] == null) { commitObj[$"@{containerName}"] = new List <Base>(); } ((List <Base>)commitObj[$"@{containerName}"]).Add(converted); conversionProgressDict["Conversion"]++; UpdateProgress(conversionProgressDict, state.Progress); converted.applicationId = autocadObjectHandle; convertedCount++; } if (renamedlayers) { RaiseNotification("Replaced illegal chars ./ with - in one or more layer names."); } if (state.CancellationTokenSource.Token.IsCancellationRequested) { return(null); } Execute.PostToUIThread(() => state.Progress.Maximum = convertedCount); var transports = new List <ITransport>() { new ServerTransport(client.Account, streamId) }; var commitObjId = await Operations.Send( commitObj, state.CancellationTokenSource.Token, transports, onProgressAction : dict => UpdateProgress(dict, state.Progress), onErrorAction : (err, exception) => { Exceptions.Add(exception); } ); if (Exceptions.Count != 0) { RaiseNotification($"Failed to send: \n {Exceptions.Last().Message}"); return(null); } if (convertedCount > 0) { var actualCommit = new CommitCreateInput { streamId = streamId, objectId = commitObjId, branchName = state.Branch.name, message = state.CommitMessage != null ? state.CommitMessage : $"Pushed {convertedCount} elements from AutoCAD.", sourceApplication = Utils.AutocadAppName }; if (state.PreviousCommitId != null) { actualCommit.parents = new List <string>() { state.PreviousCommitId }; } try { var commitId = await client.CommitCreate(actualCommit); await state.RefreshStream(); state.PreviousCommitId = commitId; PersistAndUpdateStreamInFile(state); RaiseNotification($"{convertedCount} objects sent to {state.Stream.name}."); } catch (Exception e) { Globals.Notify($"Failed to create commit.\n{e.Message}"); state.Errors.Add(e); } } else { Globals.Notify($"Did not create commit: no objects could be converted."); } return(state); }
public VolumeMeasureProperty(Units unit, T value) { BaseUnit = unit; ConversionValue = value; }
public void unitLog(Units checkUnit, params object[] output) { if (checkUnit.DebugDLog) { } }
/// <inheritdoc /> public void Gauge(string name, Func <double> valueProvider, Units unit, List <KeyValuePair <string, string> > tags = null) { MetricsStatic.Gauge(_context, name, valueProvider, unit, tags); }
static ElectricInductance() { BaseDimensions = new BaseDimensions(2, 1, -2, -2, 0, 0, 0); Info = new QuantityInfo(QuantityType.ElectricInductance, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
/// <inheritdoc /> public IMeter Meter(string name, Units unit, TimeUnits rateUnit, List <KeyValuePair <string, string> > tags = null) { return(MetricsStatic.Meter(_context, name, unit, rateUnit, tags)); }
/// <inheritdoc /> public ICounter Counter(string name, Units unit, List <KeyValuePair <string, string> > tags = null) { return(MetricsStatic.Counter(_context, name, unit, tags)); }
/// <inheritdoc /> public IHistogram Histogram(string name, Units unit, SamplingTypes samplingType, List <KeyValuePair <string, string> > tags = null) { return(MetricsStatic.Histogram(_context, name, unit, samplingType, tags)); }
/// <summary> /// converts a floating point time in seconds to an angle in /// degrees, typically for use by clocks and meters in both 2d /// and 3d. each optional boolean represents the resolution at /// which to represent the time value. this determines how /// "smooth" the clock hand will move. by default the method /// will return an angle corresponding to the current amount /// of seconds in the current minute at millisecond resolution /// </summary> public static float TimeToDegrees(float seconds, bool includeHours = false, bool includeMinutes = false, bool includeSeconds = true, bool includeMilliSeconds = true) { Units iTime = TimeToUnits(seconds); // hours @ second-resolution if (includeHours && includeMinutes && includeSeconds) { return(HoursToDegreesInternal(iTime.hours, iTime.minutes, iTime.seconds)); } // hours @ minute-resolution if (includeHours && includeMinutes) { return(HoursToDegreesInternal(iTime.hours, iTime.minutes)); } // minutes @ millisecond-resolution if (includeMinutes && includeSeconds && includeMilliSeconds) { return(MinutesToDegreesInternal(iTime.minutes, iTime.seconds, iTime.milliSeconds)); } // minutes @ second-resolution if (includeMinutes && includeSeconds) { return(MinutesToDegreesInternal(iTime.minutes, iTime.seconds)); } // DEFAULT: seconds @ millisecond-resolution if (includeSeconds && includeMilliSeconds) { return(SecondsToDegreesInternal(iTime.seconds, iTime.milliSeconds)); } // hours @ hour-resolution if (includeHours) { return(HoursToDegreesInternal(iTime.hours)); } // minutes @ minute-resolution if (includeMinutes) { return(MinutesToDegreesInternal(iTime.minutes)); } // seconds @ second-resolution if (includeSeconds) { return(TimeToDegrees(iTime.seconds)); } // milliseconds @ millisecond-resolution if (includeMilliSeconds) { return(MilliSecondsToDegreesInternal(iTime.milliSeconds)); } UnityEngine.Debug.LogError("Error: (vp_TimeUtility.TimeToDegrees) This combination of time units is not supported."); return(0.0f); }
public static Task MakeUnitTask(int varMin, int varMax) { Random r = new Random(Guid.NewGuid().GetHashCode()); string unit1 = ""; string unit2 = ""; double val; string answer = ""; Units unit = (Units)r.Next(0, 3); DistanceUnits distance = (DistanceUnits)r.Next(0, 3); WeightUnits weight = (WeightUnits)r.Next(0, 2); VolumeUnits volume = (VolumeUnits)r.Next(0, 2); switch (unit) { case Units.Distance: switch (distance) { case DistanceUnits.Metre: unit1 = "metres"; break; case DistanceUnits.Centimetre: unit1 = "centimetres"; break; case DistanceUnits.Millimetre: unit1 = "millimetres"; break; } distance = (DistanceUnits)r.Next(0, 3); switch (unit1) { case "metres": while (unit2 == unit1 || unit2 == "") { switch (distance) { case DistanceUnits.Centimetre: unit2 = "centimetres"; break; case DistanceUnits.Millimetre: unit2 = "millimetres"; break; case DistanceUnits.Metre: distance = (DistanceUnits)r.Next(0, 3); break; } } break; case "centimetres": while (unit2 == unit1 || unit2 == "") { switch (distance) { case DistanceUnits.Metre: unit2 = "metres"; break; case DistanceUnits.Millimetre: unit2 = "millimetres"; break; case DistanceUnits.Centimetre: distance = (DistanceUnits)r.Next(0, 3); break; } } break; case "millimetres": while (unit2 == unit1 || unit2 == "") { switch (distance) { case DistanceUnits.Metre: unit2 = "metres"; break; case DistanceUnits.Centimetre: unit2 = "centimetres"; break; case DistanceUnits.Millimetre: distance = (DistanceUnits)r.Next(0, 3); break; } } break; } break; case Units.Weight: switch (weight) { case WeightUnits.Kilogram: unit1 = "kilograms"; break; case WeightUnits.gram: unit1 = "grams"; break; } switch (unit1) { case "kilograms": unit2 = "gram"; break; case "grams": unit2 = "kilogram"; break; } break; case Units.Volume: switch (volume) { case VolumeUnits.Cubicmetre: unit1 = "cubicmetres"; break; case VolumeUnits.Litre: unit1 = "litres"; break; } switch (unit1) { case "cubicmetres": unit2 = "litres"; break; case "litres": unit2 = "cubicmetres"; break; } break; } val = r.Next(varMin, varMax); string taskS = ""; taskS += "How many " + unit1 + " is " + val + " " + unit2 + "?"; //conversions if (unit1 == "metres" && unit2 == "centimetres") { val = val * 0.01; } else if (unit1 == "metres" && unit2 == "millimetres") { val = val * 0.001; } else if (unit1 == "centimetres" && unit2 == "metres") { val = val * 100; } else if (unit1 == "centimetres" && unit2 == "millimetres") { val = val * 0.1; } else if (unit1 == "millimetres" && unit2 == "metres") { val = val * 1000; } else if (unit1 == "millimetres" && unit2 == "centimetres") { val = val * 10; } else if (unit1 == "litres") { val = val * 1000; } else if (unit1 == "cubicmetres") { val = val * 0.001; } else if (unit1 == "gram") { val = val * 1000; } else if (unit1 == "kilogram") { val = val * 0.001; } answer = val.ToString(); var task = new Task(taskS, answer); return(task); }
//public static double? ConvertTo(this double? valueToConvert, Units sourceUnits, Units targetUnits) //{ // switch (sourceUnits) // { // // // case Units.degreesC: // switch (targetUnits) // { // case Units.degreesF: // return (valueToConvert*1.8) + 32; // default: // throw new NotImplementedException(); // } // // // case Units.psi: // switch (targetUnits) // { // case Units.inchesH2O: // return (valueToConvert * 27.730); // case Units.feetH2O: // return (valueToConvert * 2.3108); // case Units.millimetersH2O: // return (valueToConvert * 704.32); // case Units.centimetersH2O: // return (valueToConvert * 70.432); // case Units.metersH2O: // return (valueToConvert * 0.70432); // case Units.mbar: // return (valueToConvert * 68.947); // case Units.bar: // return (valueToConvert * 0.068947); // case Units.kPa: // return (valueToConvert * 0.068947); // default: // throw new NotImplementedException(); // } // // // case Units.pounds: // switch (targetUnits) // { // case Units.kilograms: // return (valueToConvert * 0.4535); // case Units.kips: // return (valueToConvert * 0.001); // case Units.tons: // return (valueToConvert * 0.0005); // case Units.metricTons: // return (valueToConvert * 0.0004535); // case Units.kilonewtons: // return (valueToConvert * 0.00444898); // default: // throw new NotImplementedException(); // } // // // case Units.inches: // switch (targetUnits) // { // case Units.feet: // return (valueToConvert * 0.0833); // case Units.millimeters: // return (valueToConvert * 25.4); // case Units.centimeters: // return (valueToConvert * 2.54); // case Units.meters: // return (valueToConvert * 0.0254); // default: // throw new NotImplementedException(); // } // // // case Units.Digits: // switch (targetUnits) // { // case Units.microstrainC: // return (valueToConvert * 4.062); // case Units.microstrainD: // return (valueToConvert * 3.304); // case Units.microstrainE: // return (valueToConvert * 0.39102); // default: // throw new NotImplementedException(); // } // default: // throw new NotImplementedException(); // } //} public static string Conversion(Units fromUnits, Units targetUnits) { string equation = ""; switch (fromUnits) { case Units.Volts: break; case Units.AuxillaryVolts: break; case Units.Hertz: break; case Units.Percent: break; case Units.degreesC: switch (targetUnits) { case Units.degreesK: equation = "°C + 273.15"; break; case Units.degreesF: equation = "(°C * 1.8) + 32"; break; default: throw new NotImplementedException(); } break; case Units.degreesF: switch (targetUnits) { case Units.degreesK: equation = "(°F + 459.67) * .6"; break; case Units.degreesC: equation = "(°F / 1.8) - 32"; break; default: throw new NotImplementedException(); } break; case Units.degreesK: switch (targetUnits) { case Units.degreesF: equation = "(°K * 1.8) + 32"; break; case Units.degreesC: equation = "(°K * 1.8) + 32"; break; default: throw new NotImplementedException(); } break; case Units.psi: switch (targetUnits) { case Units.inchesH2O: equation = "psi * 27.730"; break; case Units.feetH2O: equation = "psi * 2.3108"; break; case Units.millimetersH2O: equation = "psi * 704.32"; break; case Units.centimetersH2O: equation = "psi * 70.432"; break; case Units.metersH2O: equation = "psi * 0.70432"; break; case Units.mbar: equation = "psi * 68.947"; break; case Units.bar: equation = "psi * 0.068947"; break; case Units.kPa: equation = "psi * 0.00068947"; break; case Units.MPa: equation = "psi * 0.00689476"; break; default: throw new NotImplementedException(); } break; case Units.inchesH2O: switch (targetUnits) { case Units.psi: equation = "inchesH2O * 0.03612629"; break; case Units.feetH2O: equation = "inchesH2O * 0.08333344"; break; case Units.millimetersH2O: equation = "inchesH2O * 25.3999947"; break; case Units.centimetersH2O: equation = "inchesH2O * 2.539999983"; break; case Units.metersH2O: equation = "inchesH2O * 0.02540650"; break; case Units.mbar: equation = "inchesH2O * 2.4884"; break; case Units.bar: equation = "inchesH2O * 0.0024884"; break; case Units.kPa: equation = "inchesH2O * 0.24884"; break; case Units.MPa: equation = "inchesH2O * 0.00024884"; break; default: throw new NotImplementedException(); } break; case Units.feetH2O: switch (targetUnits) { case Units.psi: equation = "feetH2O * 0.43352750"; break; case Units.inchesH2O: equation = "feetH2O * 12"; break; case Units.millimetersH2O: equation = "feetH2O * 304.8"; break; case Units.centimetersH2O: equation = "feetH2O * 30.48"; break; case Units.metersH2O: equation = "feetH2O * 0.3048"; break; case Units.mbar: equation = "feetH2O * 29.890669"; break; case Units.bar: equation = "feetH2O * 0.029890669"; break; case Units.kPa: equation = "feetH2O * 22.98607999"; break; case Units.MPa: equation = "feetH2O * 0.00298607"; break; default: throw new NotImplementedException(); } break; case Units.millimetersH2O: switch (targetUnits) { case Units.psi: equation = "millimetersH2O * 0.00142233"; break; case Units.inchesH2O: equation = "millimetersH2O * 0.0393701"; break; case Units.feetH2O: equation = "millimetersH2O * 0.00328084"; break; case Units.centimetersH2O: equation = "millimetersH2O * 0.1"; break; case Units.metersH2O: equation = "millimetersH2O * 0.001"; break; case Units.mbar: equation = "millimetersH2O * 0.0980665"; break; case Units.bar: equation = "millimetersH2O * 0.0000980665"; break; case Units.kPa: equation = "millimetersH2O * 0.00980665"; break; case Units.MPa: equation = "millimetersH2O * 0.00000980665"; break; default: throw new NotImplementedException(); } break; case Units.centimetersH2O: switch (targetUnits) { case Units.psi: equation = "centimetersH2O * 0.01422295"; break; case Units.inchesH2O: equation = "centimetersH2O * 0.393701"; break; case Units.feetH2O: equation = "centimetersH2O * 0.0328084"; break; case Units.millimetersH2O: equation = "centimetersH2O * 10"; break; case Units.metersH2O: equation = "centimetersH2O * 0.01"; break; case Units.mbar: equation = "centimetersH2O * 0.980638"; break; case Units.bar: equation = "centimetersH2O * 0.000980638"; break; case Units.kPa: equation = "millimetersH2O * 0.0980638"; break; case Units.MPa: equation = "millimetersH2O * 0.00009806"; break; default: throw new NotImplementedException(); } break; case Units.pounds: return(""); case Units.kilograms: return("(Lbs * 0.4535)"); case Units.kips: return("(Lbs * 0.001)"); case Units.tons: return("(Lbs * 0.0005)"); case Units.metricTons: return("(Lbs * 0.0004535)"); case Units.kilonewtons: return("(Lbs * 0.00444898)"); case Units.inches: return(""); case Units.feet: return("(in * 0.0833)"); case Units.millimeters: return("(in * 25.4)"); case Units.centimeters: return("(in * 2.54)"); case Units.meters: return("(in * 0.0254)"); case Units.Digits: return(""); case Units.microstrainC: return("(Digits * 4.062)"); case Units.microstrainD: return("(Digits * 3.304)"); case Units.microstrainE: return("(Digits * 0.39102)"); default: break; } return(equation); }
public override void Wound(Units attacker, float damage) { base.Wound(attacker, damage); }
public static string ToDisplayString(this Units unit) { switch (unit) { case Units.None: return("-"); //temperature case Units.degreesC: return("°C"); case Units.degreesF: return("°F"); case Units.degreesK: return("°K"); //Default case Units.Volts: return("V"); case Units.AuxillaryVolts: return("AuxV"); case Units.Percent: return("%"); case Units.Hertz: return("Hz"); case Units.Digits: return("Dig"); //Pressure case Units.psi: return("psi"); case Units.inchesH2O: return("inH2O"); case Units.feetH2O: return("ftH2O"); case Units.millimetersH2O: return("mmH2O"); case Units.centimetersH2O: return("cmH2O"); case Units.metersH2O: return("mH2O"); case Units.mbar: return("mbar"); case Units.bar: return("bar"); case Units.kPa: return("kPa"); case Units.MPa: return("MPa"); //Load case Units.pounds: return("Lb"); case Units.kilograms: return("Kg"); case Units.kips: return("Kips"); case Units.tons: return("tons"); case Units.metricTons: return("M/T"); case Units.kilonewtons: return("kN"); //Distance case Units.inches: return("in"); case Units.feet: return("ft"); case Units.millimeters: return("mm"); case Units.centimeters: return("cm"); case Units.meters: return("m"); //Strain case Units.microstrainC: return("µstrain (C)"); case Units.microstrainD: return("µstrain (D)"); case Units.microstrainE: return("µstrain (E)"); //Tilt case Units.Degrees: return("°"); case Units.Radians: return("Radians"); case Units.Arcseconds: return("Arcseconds"); default: return(Enum.GetName(typeof(Units), unit)); } }
static TemperatureDelta() { BaseDimensions = BaseDimensions.Dimensionless; Info = new QuantityInfo(QuantityType.TemperatureDelta, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
static Magnetization() { BaseDimensions = new BaseDimensions(-1, 0, 0, 1, 0, 0, 0); Info = new QuantityInfo(QuantityType.Magnetization, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
static ReactivePower() { BaseDimensions = new BaseDimensions(2, 1, -3, 0, 0, 0, 0); Info = new QuantityInfo(QuantityType.ReactivePower, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
public static string GetPlural(Units unitType) { return(Plural[(int)unitType]); }
public override float GetConcentrationAtLocalPosition(Vector3 localPosition, float radius, Units units) { //todo return(maxConcentration); }
/// <summary> /// Calculates the distance between 2 points, using x, y, and z coordinates /// </summary> /// <param name="ptA">The first point</param> /// <param name="ptB">The second point</param> /// <param name="units">Units of the value to return</param> /// <returns>The distance between ptA and ptB, using x, y, and z coordinates, using the specified units</returns> public static double CalculateDistance(API.Data.Point ptA, API.Data.Point ptB, Units units) { switch (units) { case Units.Feet: return(CalcUtil.CalculateDistance(ptA, ptB) / 12.0); case Units.Meters: return(CalcUtil.CalculateDistance(ptA, ptB) / 39.3701); case Units.TimeDistance: return(CalcUtil.CalculateTimeDistance(CalcUtil.CalculateDistance(ptA, ptB))); default: return(0); } }
static VolumeConcentration() { BaseDimensions = BaseDimensions.Dimensionless; Info = new QuantityInfo(QuantityType.VolumeConcentration, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
public Skill_Xiaolu_03(string skill_id, Units self) : base(skill_id, self) { }
public static bool TryParsePrefixed(string text, string[] prefixes, Units uncolonedDefault, Units colonedDefault, out Dictionary <string, TimeSpan?> matches) { return(TryParsePrefixed(text, prefixes, null, uncolonedDefault, colonedDefault, out matches)); }
static ForceChangeRate() { BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0); Info = new QuantityInfo(QuantityType.ForceChangeRate, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
/// <summary> /// Note: a special entries matches["0"] matches["1"] etc are included if `text` starts with timespans. /// </summary> /// <param name="text"></param>34 /// <param name="uncolonedDefault"></param> /// <param name="colonedDefault"></param> /// <param name="prefixes">Prefixes which are (optionally) followed by a timespan</param> /// <param name="keywords">Keywords which do not have a timespan variable after them (any timespan after it will be considered a default numbered argument)</param> /// <param name="matches"></param> /// <returns></returns> public static bool TryParsePrefixed(string text, string[] prefixes, string[] keywords, Units uncolonedDefault, Units colonedDefault, out Dictionary <string, TimeSpan?> matches) { var options = new TimeSpanParserOptions { UncolonedDefault = uncolonedDefault, ColonedDefault = colonedDefault }; return(TryParsePrefixed(text, prefixes, keywords, options, out matches)); }
static StandardFlow() { BaseDimensions = new BaseDimensions(3, 0, -1, 0, 0, 0, 0); Info = new QuantityInfo(QuantityType.StandardFlow, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions); }
/// <inheritdoc /> public ITimer Timer(string name, Units unit, SamplingTypes samplingType, TimeUnits rateUnit, TimeUnits durationUnit, List <KeyValuePair <string, string> > tags = null) { return(MetricsStatic.Timer(_context, name, unit, samplingType, rateUnit, durationUnit, tags)); }