code: def _option_prices(
      *,
      volatilities=None,
      strikes=None,
      forwards=None,
      expiries=None,
      is_call_options=True,
      is_normal_model=True,
      dtype=None,
  ):
      """Computes prices of European options using normal model.
  
      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.
        forwards: A real `Tensor` of any shape that broadcasts to the shape of
          `volatilities`. The forwards to maturity. Either this argument or the
        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.
        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_model: A boolean `Tensor` of a shape compatible with
          `volatilities`. Indicates whether the options should be priced using
          normal model (if True) or lognormal model (if False). If not supplied,
          normal model is assumed.
        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.
  
      Returns:
        Options prices computed using normal model for the underlying.
      """
      dtype = dtype or tf.constant(0.0).dtype
  
      def _ncdf(x):
          sqrt_2 = tf.math.sqrt(tf.constant(2.0, dtype=dtype))
          return (tf.math.erf(x / sqrt_2) + 1) / 2
  
      sqrt_var = tf.math.sqrt(expiries) * volatilities
      d = (forwards - strikes) / sqrt_var
      mu = tf.constant(0.0, dtype=dtype)
      loc = tf.constant(1.0, dtype=dtype)
      value = tf.where(
          is_normal_model,
          tf.where(
              is_call_options,
              (forwards - strikes) * _ncdf(d)
              + sqrt_var * tfp.distributions.Normal(mu, loc).prob(d),
              (strikes - forwards) * _ncdf(-d)
              + sqrt_var * tfp.distributions.Normal(mu, loc).prob(d),
          ),
          black_scholes.option_price(
              volatilities=volatilities,
              strikes=strikes,
              expiries=expiries,
              forwards=forwards,
              is_call_options=is_call_options,
              dtype=dtype,
          ),
      )
      value = tf.where(
          expiries > 0,
          value,
          tf.where(
              is_call_options,
              tf.maximum(forwards - strikes, 0.0),
              tf.maximum(strikes - forwards, 0.0),
          ),
      )
      return value
  
imports: import itertools
  import tensorflow.compat.v2
  import tensorflow_probability
  from tf_quant_finance import black_scholes
  from tf_quant_finance import datetime
  from tf_quant_finance.experimental.instruments import cashflow_stream
  from tf_quant_finance.experimental.instruments import interest_rate_swap
  from tf_quant_finance.experimental.instruments import rates_common
  from tf_quant_finance.math import integration
label_desc: Use image node_id 1 for calling a global function with example usage: _option_prices() and returns: value, unknown