class_docstr: Represents a batch of floating rate notes.
  
  Floating rate notes are bond securities where the value of the coupon is not
  fixed at the time of issuance but is rather reset for every coupon period
  typically based on a benchmark index such as LIBOR rate [1].
  
  For example, consider a floating rate note with settlement date T_0 and
  maturity date T_n and equally spaced coupon payment dates T_1, T_2, ..., T_n
  such that
  
  T_0 < T_1 < T_2 < ... < T_n and dt_i = T_(i+1) - T_i    (A)
  
  The floating rate is fixed on T_0, T_1, ..., T_(n-1) and the payments are
  typically made on T_1, T_2, ..., T_n (payment dates) and the i-th coupon
  payment is given by:
  
  c_i = N * tau_i * L[T_{i-1}, T_i]                        (B)
  
  where N is the notional amount, tau_i is the daycount fraction for the period
  [T_{i-1}, T_i] and L[T_{i-1}, T_i] is the flotaing rate reset at T_{i-1}.
  
  The FloatingRateNote class can be used to create and price multiple FRNs
  simultaneously. However all FRNs within a FloatingRateNote object must be
  priced using a common reference and discount curve.
  
  #### Example:
  The following example illustrates the construction of an IRS instrument and
  calculating its price.
  
  ```python
  import numpy as np
  import tensorflow as tf
  import tf_quant_finance as tff
  dates = tff.datetime
  instruments = tff.experimental.instruments
  rc = tff.experimental.instruments.rates_common
  
  dtype = np.float64
  settlement_date = dates.convert_to_date_tensor([(2021, 1, 15)])
  maturity_date = dates.convert_to_date_tensor([(2022, 1, 15)])
  valuation_date = dates.convert_to_date_tensor([(2021, 1, 15)])
  period_3m = dates.periods.months(3)
  flt_spec = instruments.FloatCouponSpecs(
      coupon_frequency=period_3m,
      reference_rate_term=period_3m,
      reset_frequency=period_3m,
      currency='usd',
      notional=100.,
      businessday_rule=dates.BusinessDayConvention.NONE,
      coupon_basis=0.,
      coupon_multiplier=1.,
      daycount_convention=instruments.DayCountConvention.ACTUAL_365)
  
  frn = instruments.FloatingRateNote(settlement_date, maturity_date,
                                     [flt_spec],
                                     dtype=dtype)
  
  curve_dates = valuation_date + dates.periods.months([0, 6, 12, 36])
  reference_curve = instruments.RateCurve(
      curve_dates,
      np.array([0.0, 0.005, 0.007, 0.015], dtype=dtype),
      valuation_date=valuation_date,
      dtype=dtype)
  market = instruments.InterestRateMarket(discount_curve=reference_curve,
                                          reference_curve=reference_curve)
  
  price = frn.price(valuation_date, market)
  # Expected result: 100.
  ```
  
  #### References:
  [1]: Tomas Bjork. Arbitrage theory in continuous time, Second edition.
      Chapter 20. 2004.
docstr: Returns the price of the FRNs on the valuation date.
  
  Args:
    valuation_date: A scalar `DateTensor` specifying the date on which
      valuation is being desired.
    market: A namedtuple of type `InterestRateMarket` which contains the
      necessary information for pricing the FRNs.
    model: Reserved for future use.
    name: Python str. The name to give to the ops created by this function.
      Default value: `None` which maps to 'price'.
  
  Returns:
    A Rank 1 `Tensor` of real dtype containing the price of each FRN
    based on the input market data.
docstr_tok: ["Returns","the","price","of","the","FRNs","on","the","valuation","date",".","Args",":","valuation_date",":","A","scalar","`","DateTensor","`","specifying","the","date","on","which","valuation","is","being","desired",".","market",":","A","namedtuple","of","type","`","InterestRateMarket","`","which","contains","the","necessary","information","for","pricing","the","FRNs",".","model",":","Reserved","for","future","use",".","name",":","Python","str",".","The","name","to","give","to","the","ops","created","by","this","function",".","Default","value",":","`","None","`","which","maps","to","'price","'",".","Returns",":","A","Rank","1","`","Tensor","`","of","real","dtype","containing","the","price","of","each","FRN","based","on","the","input","market","data","."]
code: def price(self, valuation_date, market, model=None, name=None):
      """Returns the price of the FRNs on the valuation date.
  
      Args:
        valuation_date: A scalar `DateTensor` specifying the date on which
          valuation is being desired.
        market: A namedtuple of type `InterestRateMarket` which contains the
          necessary information for pricing the FRNs.
        model: Reserved for future use.
        name: Python str. The name to give to the ops created by this function.
          Default value: `None` which maps to 'price'.
  
      Returns:
        A Rank 1 `Tensor` of real dtype containing the price of each FRN
        based on the input market data.
      """
  
      name = name or (self._name + "_price")
      with tf.name_scope(name):
          discount_curve = market.discount_curve
          coupon_cf = self._cashflows.price(
              valuation_date, market, model
          )
          principal_cf = (
              self._notional
              * discount_curve.get_discount_factor(self._maturity_date)
          )
          return coupon_cf + principal_cf
  
imports: import tensorflow.compat.v2
  from tf_quant_finance import datetime
  from tf_quant_finance.experimental.instruments import cashflow_stream
label_desc: Use image node_id 2 for calling the FloatingRateNote obj's underlying member method code with example usage: obj.price(valuation_date, market, model, name) and returns: unknown