Inheritance: MonoBehaviour
 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;
 }
Example #2
0
 // 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;
            }
        }
Example #5
0
 /// <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);
     }
 }
Example #6
0
        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);
        }
Example #7
0
 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
            });
 }
Example #10
0
 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;
 }
Example #15
0
 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;
 }
Example #16
0
        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;
 }
Example #18
0
        /// <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;
        }
Example #19
0
 public double ToKG(double value, Units unit)
 {
     switch (unit)
     {
         case Units.T:
             return value * 1000;
         default:
             throw new Exception("Uncorrect cast to SI");
     }
 }
Example #20
0
 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");
     }
 }
Example #21
0
        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
             };
        }
Example #22
0
 /// <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;
     }
 }
Example #23
0
        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;
        }
Example #24
0
		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;
        }
Example #26
0
 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;
    }
Example #28
0
        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;
        }
Example #29
0
		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);
      }

    }
Example #31
0
 static BitRate()
 {
     BaseDimensions = BaseDimensions.Dimensionless;
     Info           = new QuantityInfo(QuantityType.BitRate, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
 }
Example #32
0
 static VitaminA()
 {
     BaseDimensions = BaseDimensions.Dimensionless;
     Info           = new QuantityInfo(QuantityType.VitaminA, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
 }
Example #33
0
 public override void Draw(SectionModule section)
 {
     this.DrawLine(Units.ToDistance(FlightGlobals.ship_orbit.semiMinorAxis, 3), section.IsHud);
 }
Example #34
0
 public static string GetSingular(Units unitType)
 {
     return(Singular[(int)unitType]);
 }
Example #35
0
        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);
        }
Example #36
0
 public VolumeMeasureProperty(Units unit, T value)
 {
     BaseUnit        = unit;
     ConversionValue = value;
 }
Example #37
0
 public void unitLog(Units checkUnit, params object[] output)
 {
     if (checkUnit.DebugDLog)
     {
     }
 }
Example #38
0
 /// <inheritdoc />
 public void Gauge(string name, Func <double> valueProvider, Units unit, List <KeyValuePair <string, string> > tags = null)
 {
     MetricsStatic.Gauge(_context, name, valueProvider, unit, tags);
 }
Example #39
0
 static ElectricInductance()
 {
     BaseDimensions = new BaseDimensions(2, 1, -2, -2, 0, 0, 0);
     Info           = new QuantityInfo(QuantityType.ElectricInductance, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
 }
Example #40
0
 /// <inheritdoc />
 public IMeter Meter(string name, Units unit, TimeUnits rateUnit, List <KeyValuePair <string, string> > tags = null)
 {
     return(MetricsStatic.Meter(_context, name, unit, rateUnit, tags));
 }
Example #41
0
 /// <inheritdoc />
 public ICounter Counter(string name, Units unit, List <KeyValuePair <string, string> > tags = null)
 {
     return(MetricsStatic.Counter(_context, name, unit, tags));
 }
Example #42
0
 /// <inheritdoc />
 public IHistogram Histogram(string name, Units unit, SamplingTypes samplingType, List <KeyValuePair <string, string> > tags = null)
 {
     return(MetricsStatic.Histogram(_context, name, unit, samplingType, tags));
 }
Example #43
0
    /// <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);
    }
Example #44
0
        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);
        }
Example #45
0
        //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);
        }
Example #46
0
 public override void Wound(Units attacker, float damage)
 {
     base.Wound(attacker, damage);
 }
Example #47
0
        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));
            }
        }
Example #48
0
 static TemperatureDelta()
 {
     BaseDimensions = BaseDimensions.Dimensionless;
     Info           = new QuantityInfo(QuantityType.TemperatureDelta, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
 }
Example #49
0
 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);
 }
Example #51
0
 public static string GetPlural(Units unitType)
 {
     return(Plural[(int)unitType]);
 }
Example #52
0
 public override float GetConcentrationAtLocalPosition(Vector3 localPosition, float radius, Units units)
 {
     //todo
     return(maxConcentration);
 }
Example #53
0
        /// <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)
 {
 }
Example #56
0
 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));
 }
Example #57
0
 static ForceChangeRate()
 {
     BaseDimensions = new BaseDimensions(1, 1, -3, 0, 0, 0, 0);
     Info           = new QuantityInfo(QuantityType.ForceChangeRate, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
 }
Example #58
0
        /// <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));
        }
Example #59
0
 static StandardFlow()
 {
     BaseDimensions = new BaseDimensions(3, 0, -1, 0, 0, 0, 0);
     Info           = new QuantityInfo(QuantityType.StandardFlow, Units.Cast <Enum>().ToArray(), BaseUnit, Zero, BaseDimensions);
 }
Example #60
0
 /// <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));
 }