code: def binary_price(
      *,
      volatilities: types.RealTensor,
      strikes: types.RealTensor,
      expiries: types.RealTensor,
      spots: types.RealTensor = None,
      forwards: types.RealTensor = None,
      discount_rates: types.RealTensor = None,
      dividend_rates: types.RealTensor = None,
      discount_factors: types.RealTensor = None,
      is_call_options: types.BoolTensor = None,
      is_normal_volatility: bool = False,
      dtype: tf.DType = None,
      name: str = None,
  ) -> types.RealTensor:
      """Computes the Black Scholes price for a batch of binary call or put options.
  
      The binary call (resp. put) option priced here is that which pays off a unit
      of cash if the underlying asset has a value greater (resp. smaller) than the
      strike price at expiry. Hence the binary option price is the discounted
      probability that the asset will end up higher (resp. lower) than the
      strike price at expiry.
  
      #### Example
  
      ```python
        # Price a batch of 5 binary call options.
        volatilities = np.array([0.0001, 102.0, 2.0, 0.1, 0.4])
        forwards = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
        # Strikes will automatically be broadcasted to shape [5].
        strikes = np.array([3.0])
        # Expiries will be broadcast to shape [5], i.e. each option has strike=3
        # and expiry = 1.
        expiries = 1.0
        computed_prices = tff.black_scholes.binary_price(
            volatilities=volatilities,
            strikes=strikes,
            expiries=expiries,
            forwards=forwards)
      # Expected print output of prices:
      # [0.         0.         0.15865525 0.99764937 0.85927418]
      ```
  
      #### References:
  
      [1] Hull, John C., Options, Futures and Other Derivatives. Pearson, 2018.
      [2] Wikipedia contributors. Binary option. Available at:
      https://en.wikipedia.org/w/index.php?title=Binary_option
  
      Args:
        volatilities: Real `Tensor` of any shape and dtype. The volatilities to
          expiry of the options to price.
        strikes: A real `Tensor` of the same dtype and compatible shape as
          `volatilities`. The strikes of the options to be priced.
        expiries: A real `Tensor` of same dtype and compatible shape as
          `volatilities`. The expiry of each option. The units should be such that
          `expiry * volatility**2` is dimensionless.
        spots: A real `Tensor` of any shape that broadcasts to the shape of the
          `volatilities`. The current spot price of the underlying. Either this
          argument or the `forwards` (but not both) must be supplied.
        forwards: A real `Tensor` of any shape that broadcasts to the shape of
          `volatilities`. The forwards to maturity. Either this argument or the
          `spots` must be supplied but both must not be supplied.
        discount_rates: An optional real `Tensor` of same dtype as the
          `volatilities` and of the shape that broadcasts with `volatilities`.
          If not `None`, discount factors are calculated as e^(-rT),
          where r are the discount rates, or risk free rates. At most one of
          discount_rates and discount_factors can be supplied.
          Default value: `None`, equivalent to r = 0 and discount factors = 1 when
          discount_factors also not given.
        dividend_rates: An optional real `Tensor` of same dtype as the
          `volatilities` and of the shape that broadcasts with `volatilities`.
          Default value: `None`, equivalent to q = 0.
        discount_factors: An optional real `Tensor` of same dtype as the
          `volatilities`. If not None, these are the discount factors to expiry
          (i.e. e^(-rT)). If None, no discounting is applied (i.e. the undiscounted
          option price is returned). If `spots` is supplied and `discount_factors`
          is not None then this is also used to compute the forwards to expiry.
          Default value: None, equivalent to discount factors = 1.
        is_call_options: A boolean `Tensor` of a shape compatible with
          `volatilities`. Indicates whether the option is a call (if True) or a put
          (if False). If not supplied, call options are assumed.
        is_normal_volatility: An optional Python boolean specifying whether the
          `volatilities` correspond to lognormal Black volatility (if False) or
          normal Black volatility (if True).
          Default value: False, which corresponds to lognormal volatility.
        dtype: Optional `tf.DType`. If supplied, the dtype to be used for conversion
          of any supplied non-`Tensor` arguments to `Tensor`.
          Default value: None which maps to the default dtype inferred by TensorFlow
            (float32).
        name: str. The name for the ops created by this function.
          Default value: None which is mapped to the default name `binary_price`.
  
      Returns:
        binary_prices: A `Tensor` of the same shape as `forwards`. The Black
        Scholes price of the binary options.
  
      Raises:
        ValueError: If both `forwards` and `spots` are supplied or if neither is
          supplied.
        ValueError: If both `discount_rates` and `discount_factors` is supplied.
      """
      if (spots is None) == (forwards is None):
          raise ValueError(
              "Either spots or forwards must be supplied but not both."
          )
      if (discount_rates is not None) and (
          discount_factors is not None
      ):
          raise ValueError(
              "At most one of discount_rates and discount_factors may "
              "be supplied"
          )
  
      with tf.name_scope(name or "binary_price"):
          strikes = tf.convert_to_tensor(
              strikes, dtype=dtype, name="strikes"
          )
          dtype = strikes.dtype
          volatilities = tf.convert_to_tensor(
              volatilities, dtype=dtype, name="volatilities"
          )
          expiries = tf.convert_to_tensor(
              expiries, dtype=dtype, name="expiries"
          )
  
          if discount_rates is not None:
              discount_rates = tf.convert_to_tensor(
                  discount_rates, dtype=dtype, name="discount_rates"
              )
              discount_factors = tf.exp(-discount_rates * expiries)
          elif discount_factors is not None:
              discount_factors = tf.convert_to_tensor(
                  discount_factors, dtype=dtype, name="discount_factors"
              )
              discount_rates = -tf.math.log(discount_factors) / expiries
          else:
              discount_rates = tf.convert_to_tensor(
                  0.0, dtype=dtype, name="discount_rates"
              )
              discount_factors = tf.convert_to_tensor(
                  1.0, dtype=dtype, name="discount_factors"
              )
  
          if dividend_rates is None:
              dividend_rates = tf.convert_to_tensor(
                  0.0, dtype=dtype, name="dividend_rates"
              )
  
          if forwards is not None:
              forwards = tf.convert_to_tensor(
                  forwards, dtype=dtype, name="forwards"
              )
          else:
              spots = tf.convert_to_tensor(
                  spots, dtype=dtype, name="spots"
              )
              forwards = spots / discount_factors
  
          sqrt_var = volatilities * tf.math.sqrt(expiries)
  
          if is_normal_volatility:  # normal model
              d2 = (forwards - strikes) / sqrt_var
          else:  # lognormal model
              d2 = (
                  tf.math.log(forwards / strikes) / sqrt_var
                  - sqrt_var / 2
              )
  
          zero_volatility_call_payoff = tf.where(
              forwards > strikes,
              tf.ones_like(strikes, dtype=dtype),
              tf.zeros_like(strikes, dtype=dtype),
          )
          undiscounted_calls = tf.where(
              sqrt_var > 0, _ncdf(d2), zero_volatility_call_payoff
          )
  
          if is_call_options is None:
              return discount_factors * undiscounted_calls
  
          undiscounted_puts = 1 - undiscounted_calls
          predicate = tf.broadcast_to(
              is_call_options, tf.shape(undiscounted_calls)
          )
          return discount_factors * tf.where(
              predicate, undiscounted_calls, undiscounted_puts
          )
  
file_path: tf-quant-finance/tf_quant_finance/black_scholes/vanilla_prices.py
imports: import numpy
  import tensorflow.compat.v2
  from tf_quant_finance import types
label_desc: Use image node_id 3 for calling a global function with example usage: binary_price() and returns: unknown, unknown