/// <summary>
        ///  Converts volume in currency Y to currency Z (profit currency to deposit currency)
        /// </summary>
        /// <param name="calculator">Financial calculator.</param>
        /// <param name="amount">Volume.</param>
        /// <param name="symbol">Symbol X/Y.</param>
        /// <param name="depositCurrency">Deposit currency.</param>
        /// <returns>Rate or null if rate cannot be calculated.</returns>
        public static double? ConvertYToZ(this FinancialCalculator calculator, double amount, string symbol, string depositCurrency)
        {
            if (calculator == null)
                throw new ArgumentNullException(nameof(calculator));
            if (symbol == null)
                throw new ArgumentNullException(nameof(symbol));
            if (depositCurrency == null)
                throw new ArgumentNullException(nameof(depositCurrency));

            if (calculator.MarketState == null)
                calculator.Calculate();

            try
            {
                double rate = 1.0;
                if (amount >= 0)
                {
                    rate = (double)calculator.MarketState.ConversionMap.GetPositiveProfitConversion(symbol, depositCurrency).Value;
                }
                else
                {
                    rate = (double)calculator.MarketState.ConversionMap.GetNegativeProfitConversion(symbol, depositCurrency).Value;
                }
                return rate * amount;
            }
            catch (BusinessLogicException)
            {
                return null;
            }
        } 
        public static double? CalculateAssetRate(this FinancialCalculator calculator, double asset, string assetCurrency, string currency)
        {
            if (calculator == null)
                throw new ArgumentNullException(nameof(calculator));
            if (assetCurrency == null)
                throw new ArgumentNullException(nameof(assetCurrency));
            if (currency == null)
                throw new ArgumentNullException(nameof(currency));

            if (calculator.MarketState == null)
                calculator.Calculate();

            try
            {
                if (asset >= 0)
                    return (double)calculator.MarketState.ConversionMap.GetPositiveAssetConversion(assetCurrency, currency).Value;
                else
                    return (double)calculator.MarketState.ConversionMap.GetNegativeAssetConversion(assetCurrency, currency).Value;
            }
            catch (BusinessLogicException)
            {
                return null;
            }
        }
Example #3
0
 /// <summary>
 /// Calculates phase using Atan2 (secondImage / firstImage). 
 /// </summary>
 /// <param name="imageX">First image.</param>
 /// <param name="imageY">Second image.</param>
 /// <returns>Phase.</returns>
 public static Gray<double>[,] Phase(this  Gray<double>[,] imageX, Gray<double>[,] imageY)
 {
     return imageX.Calculate(imageY, phase_Double, inPlace: false);
 }
Example #4
0
 /// <summary>
 /// Calculates phase using Atan2 (secondImage / firstImage). 
 /// </summary>
 /// <param name="imageX">First image.</param>
 /// <param name="imageY">Second image.</param>
 /// <returns>Phase.</returns>
 public static Gray<float>[,] Phase(this  Gray<float>[,] imageX, Gray<float>[,] imageY)
 {
     return imageX.Calculate(imageY, phase_Float, inPlace: false);
 }
 /// <summary>
 /// Multiplies two complex images element-wise.
 /// </summary>
 /// <param name="imageA">First image.</param>
 /// <param name="imageB">Second image.</param>
 /// <param name="inPlace">
 /// True to save the result in the first image, false otherwise.
 /// <para>If true the returned image is the source image.</para>
 /// </param>
 /// <returns>Multiplied image.</returns>
 public static ComplexF[,] MulComplex(this ComplexF[,] imageA, ComplexF[,] imageB, bool inPlace = false)
 {
     return imageA.Calculate(imageB, mulComplex, inPlace);
 }
 /// <summary>
 /// Calculates magnitude using Euclidean distance. 
 /// </summary>
 /// <param name="imageA">First image.</param>
 /// <param name="imageB">Second image.</param>
 /// <returns>Magnitude.</returns>
 public static Gray<double>[,] Magnitude(this Gray<double>[,] imageA, Gray<double>[,] imageB)
 {
     return imageA.Calculate(imageB, magnitude_Double, inPlace: false);
 }
 /// <summary>
 /// Calculates magnitude using Euclidean distance. 
 /// </summary>
 /// <param name="imageA">First image.</param>
 /// <param name="imageB">Second image.</param>
 /// <returns>Magnitude.</returns>
 public static Gray<float>[,] Magnitude(this Gray<float>[,] imageA, Gray<float>[,] imageB)
 {
     return imageA.Calculate(imageB, magnitude_Float, inPlace: false);
 }