public void FrequencyConversions(double value1, FrequencyUnit units1, double value2, FrequencyUnit units2)
{
new Frequency(value1, units1) {
Units = units2
}.Value.ShouldBeWithinEpsilonOf(value2);
new Frequency(value2, units2) {
Units = units1
}.Value.ShouldBeWithinEpsilonOf(value1);
}
/// <summary>
/// Get string representation of value and unit. Using current UI culture and two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <returns>String representation.</returns>
public string ToString(FrequencyUnit unit)
{
return(ToString(unit, null, 2));
}
public static string GetAbbreviation(FrequencyUnit unit)
{
return(GetAbbreviation(unit, null));
}
/// <summary>
/// Converts this Duration to another Duration with the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>A Duration with the specified unit.</returns>
public Frequency ToUnit(FrequencyUnit unit)
{
var convertedValue = GetValueAs(unit);
return(new Frequency(convertedValue, unit));
}
/// <summary>
/// Dynamically convert from value and unit enum <see cref="FrequencyUnit" /> to <see cref="Frequency" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>Frequency unit value.</returns>
public static Frequency From(double value, FrequencyUnit fromUnit)
{
return(new Frequency(value, fromUnit));
}
/// <summary> /// 设置中心频率 /// </summary> /// <param name="freq"></param> /// <param name="unit"></param> public abstract bool SetCenterFreq(int freq, FrequencyUnit unit);
public void setFrequencyUnit(FrequencyUnit unit)
{
frequencyUnit.Value = unit;
}
public Frequency(decimal value, FrequencyUnit unit)
{
_frequence = value;
_frequenceUnit = unit;
_hertz = (int)(value * (int)unit);
}
public static Frequency From(QuantityValue value, FrequencyUnit fromUnit)
#endif
{
return(new Frequency((double)value, fromUnit));
}
public static Frequency From(double value, FrequencyUnit fromUnit)
public string ToString(FrequencyUnit unit, CultureInfo culture, string format, params object[] args)
{
return(string.Format(culture, format, UnitFormatter.GetFormatArgs(unit, As(unit), culture, args)));
}
public void SetOrphanMark(string id, string value, FrequencyUnit unit)
{
string cmd = "Mark" + id + " " + value + unit.ToString();
this.ExecuteCommand(cmd);
}
public void SetMark(string id, string value, FrequencyUnit unit)
{
string cmd = "Mark" + id + " " + value + unit.ToString();
this.ExecuteCommand(cmd);
if (!this._marksSetCount.Contains(id))
{
this._marksSetCount.Add(id);
this.MarksCount++;
}
}
private void onFrequencyUnitChange(FrequencyUnit value, object sender)
{
updateFrequency();
}
/// <summary>
/// Dynamically convert from value and unit enum <see cref="FrequencyUnit" /> to <see cref="Frequency" />.
/// </summary>
/// <param name="value">Value to convert from.</param>
/// <param name="fromUnit">Unit to convert from.</param>
/// <returns>Frequency unit value.</returns>
public static Frequency?From(QuantityValue?value, FrequencyUnit fromUnit)
{
return(value.HasValue ? new Frequency((double)value.Value, fromUnit) : default(Frequency?));
}
public Frequency(float value, FrequencyUnit unit)
{
this.value = value;
this.unit = unit;
}
public static string GetAbbreviation(
FrequencyUnit unit,
#if WINDOWS_UWP
[CanBeNull] string cultureName)
public static string GetAbbreviation(FrequencyUnit unit, [CanBeNull] IFormatProvider provider)
{
provider = provider ?? UnitSystem.DefaultCulture;
return(UnitSystem.GetCached(provider).GetDefaultAbbreviation(unit));
}
public void SetOrphanMark(string id, string value, FrequencyUnit unit)
{
string cmd = "Mark" + id + " " + value + unit.ToString();
this.ExecuteCommand(cmd);
}
/// <summary> /// 设置终止频率 /// </summary> /// <param name="freq"></param> /// <param name="unit"></param> public abstract bool SetStopFreq(int freq, FrequencyUnit unit);
public ISignalGenerator WithUnit(FrequencyUnit unit)
{
_Unit = unit;
return(this);
}
/// <summary> /// 设置带宽 /// </summary> /// <param name="span"></param> /// <param name="unit"></param> public abstract bool SetSpan(int span, FrequencyUnit unit);
public static void GetYCordRangeLabels(string[] ranges, Double rangeMax, Double rangeMin, FrequencyUnit unit)
{
string[] sUnit = { "Hz", "k", "M", "" };
int index = (int)unit;
if (-1 == index)//No unit
{
index = sUnit.Length - 1;
}
ranges[0] = rangeMax.ToString() + sUnit[index];
ranges[1] = rangeMin.ToString() + sUnit[index];
ranges[2] = (rangeMax == -rangeMin) ? "0" : "";
}
/// <summary> /// Convert to the unit representation <paramref name="unit" />. /// </summary> /// <returns>Value converted to the specified unit.</returns> public double As(FrequencyUnit unit) => GetValueAs(unit);
public void SetYCoordinate(MathInterval rangeY, Label label_YCoordinateMax, Label label_YCoordinateMin, Label label_YCoordinateMiddle, FrequencyUnit unit)
{
m_YcoordinateMax = rangeY.Max;
m_YcoordinateMin = rangeY.Min;
string sUnit = "";
double middleY;
switch (unit)
{
case FrequencyUnit.Hz:
sUnit = "Hz";
break;
case FrequencyUnit.KHz:
sUnit = "k";
m_YcoordinateMax = rangeY.Max * 1000;
m_YcoordinateMin = rangeY.Min * 1000;
break;
case FrequencyUnit.MHz:
sUnit = "M";
m_YcoordinateMax = rangeY.Max * 1000000;
m_YcoordinateMin = rangeY.Min * 1000000;
break;
default:
break;
}
label_YCoordinateMax.Text = rangeY.Max.ToString() + " " + sUnit;
label_YCoordinateMin.Text = rangeY.Min.ToString();
middleY = (rangeY.Max - rangeY.Min) / 2 + rangeY.Min;
label_YCoordinateMiddle.Text = middleY.ToString() + " " + sUnit;
}
/// <summary>
/// Creates the quantity with the given numeric value and unit.
/// </summary>
/// <param name="value">The numeric value to construct this quantity with.</param>
/// <param name="unit">The unit representation to construct this quantity with.</param>
/// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
public Frequency(double value, FrequencyUnit unit)
{
_value = value;
_unit = unit;
}
/// <summary> /// 设置中心频率 /// </summary> /// <param name="value">频率</param> /// <param name="unit">频率单位</param> /// <returns></returns> public abstract bool SetCenterFreq(double value, FrequencyUnit unit);
public static string GetAbbreviation(FrequencyUnit unit, [CanBeNull] Culture culture)
{
return(UnitSystem.GetCached(culture).GetDefaultAbbreviation(unit));
}
/// <summary>
/// Initializes a new instance of the <see cref="Gu.Units.Wpf.FrequencyConverter"/> class.
/// </summary>
/// <param name="unit"><see cref="Gu.Units.FrequencyUnit"/>.</param>
public FrequencyConverter(FrequencyUnit unit)
{
this.Unit = unit;
}
/// <summary>
/// Get string representation of value and unit. Using two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <param name="culture">Culture to use for localization and number formatting.</param>
/// <returns>String representation.</returns>
public string ToString(FrequencyUnit unit, [CanBeNull] Culture culture)
{
return(ToString(unit, culture, 2));
}
/// <summary>
/// Get unit abbreviation string.
/// </summary>
/// <param name="unit">Unit to get abbreviation for.</param>
/// <returns>Unit abbreviation string.</returns>
/// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
public static string GetAbbreviation(FrequencyUnit unit, [CanBeNull] string cultureName)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitAbbreviationsCache.Default.GetDefaultAbbreviation(unit, provider));
}
public MinerConfigSettings(Coin[] coinsMined, int apiPort, int[][] coinVideoCardIntensity, FrequencyUnit coreClock, FrequencyUnit memoryClock, ElectricPotentialDcUnit memoryVoltage, int numVideoCardsToPowerUpInParallel, string[] poolPasswords, string[][] pools, string[] poolWallets, MinerSWE kind)
{
CoinsMined = coinsMined ?? throw new ArgumentNullException(nameof(coinsMined));
ApiPort = apiPort;
CoinVideoCardIntensity = coinVideoCardIntensity ?? throw new ArgumentNullException(nameof(coinVideoCardIntensity));
CoreClock = coreClock;
MemoryClock = memoryClock;
MemoryVoltage = memoryVoltage;
NumVideoCardsToPowerUpInParallel = numVideoCardsToPowerUpInParallel;
PoolPasswords = poolPasswords ?? throw new ArgumentNullException(nameof(poolPasswords));
Pools = pools ?? throw new ArgumentNullException(nameof(pools));
PoolWallets = poolWallets ?? throw new ArgumentNullException(nameof(poolWallets));
Kind = kind;
}
public static bool TryParseUnit(string str, out FrequencyUnit unit)
{
return(TryParseUnit(str, null, out unit));
}
public Frequency(decimal hz)
{
_frequence = hz;
_frequenceUnit = FrequencyUnit.Hz;
_hertz = hz;
}
/// <summary>
/// Parse a unit string.
/// </summary>
/// <param name="str">String to parse. Typically in the form: {number} {unit}</param>
/// <param name="unit">The parsed unit if successful.</param>
/// <returns>True if successful, otherwise false.</returns>
/// <example>
/// Length.TryParseUnit("m", new CultureInfo("en-US"));
/// </example>
/// <param name="cultureName">Name of culture (ex: "en-US") to use when parsing number and unit. Defaults to <see cref="GlobalConfiguration.DefaultCulture" /> if null.</param>
public static bool TryParseUnit(string str, [CanBeNull] string cultureName, out FrequencyUnit unit)
{
IFormatProvider provider = GetFormatProviderFromCultureName(cultureName);
return(UnitParser.Default.TryParse <FrequencyUnit>(str, provider, out unit));
}
/// <summary>
/// Get string representation of value and unit. Using two significant digits after radix.
/// </summary>
/// <param name="unit">Unit representation to use.</param>
/// <param name="provider">Format to use for localization and number formatting. Defaults to <see cref="UnitSystem.DefaultCulture" />.</param>
/// <returns>String representation.</returns>
public string ToString(FrequencyUnit unit, [CanBeNull] IFormatProvider provider)
{
return(ToString(unit, provider, 2));
}
/// <summary>
/// Converts this Frequency to another Frequency with the unit representation <paramref name="unit" />.
/// </summary>
/// <returns>A Frequency with the specified unit.</returns>
public Frequency ToUnit(FrequencyUnit unit)
{
var convertedValue = AsBaseNumericType(unit);
return(new Frequency(convertedValue, unit));
}
Frequency(double numericValue, FrequencyUnit unit)
{
_value = numericValue;
_unit = unit;
}
protected static string CreateSuffix(SymbolFormat format, FrequencyUnit unit)
{
return default(Frequency).ToString(unit, format).Trim('0');
}
