Update javadoc generation

Signed-off-by: Ryan Nett <[email protected]>

Author: rnett

tensorflow-kotlin-parent/tensorflow-core-kotlin/pom.xml

@@ -121,7 +121,6 @@
             <configuration>
               <sourceDirs>
                 <sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
-                <sourceDir>${project.basedir}/src/gen/annotations</sourceDir>
                 <sourceDir>${project.basedir}/../../tensorflow-core/tensorflow-core-api/src/gen/java</sourceDir>
                 <sourceDir>${project.basedir}/../../tensorflow-core/tensorflow-core-api/src/gen/annotations</sourceDir>
                 <sourceDir>${project.basedir}/../../tensorflow-core/tensorflow-core-api/src/main/java</sourceDir>

tensorflow-kotlin-parent/tensorflow-core-kotlin/src/gen/annotations/org/tensorflow/op/kotlin/AudioOps.kt

@@ -51,21 +51,25 @@ public class AudioOps(
      *  slices of frequency information, one slice for each window of time. By joining
      *  these together into a sequence, they form a distinctive fingerprint of the sound
      *  over time.
-     *  This op expects to receive audio data as an input, stored as floats in the range
+     *
+     * This op expects to receive audio data as an input, stored as floats in the range
      *  -1 to 1, together with a window width in samples, and a stride specifying how
      *  far to move the window between slices. From this it generates a three
      *  dimensional output. The first dimension is for the channels in the input, so a
      *  stereo audio input would have two here for example. The second dimension is time,
      *  with successive frequency slices. The third dimension has an amplitude value for
      *  each frequency during that time slice.
-     *  This means the layout when converted and saved as an image is rotated 90 degrees
+     *
+     * This means the layout when converted and saved as an image is rotated 90 degrees
      *  clockwise from a typical spectrogram. Time is descending down the Y axis, and
      *  the frequency decreases from left to right.
-     *  Each value in the result represents the square root of the sum of the real and
+     *
+     * Each value in the result represents the square root of the sum of the real and
      *  imaginary parts of an FFT on the current window of samples. In this way, the
      *  lowest dimension represents the power of each frequency in the current window,
      *  and adjacent windows are concatenated in the next dimension.
-     *  To get a more intuitive and visual look at what this operation does, you can run
+     *
+     * To get a more intuitive and visual look at what this operation does, you can run
      *  tensorflow/examples/wav_to_spectrogram to read in an audio file and save out the
      *  resulting spectrogram as a PNG image.
      *
@@ -99,16 +103,19 @@ public class AudioOps(
     /**
      * Decode a 16-bit PCM WAV file to a float tensor.
      *  The -32768 to 32767 signed 16-bit values will be scaled to -1.0 to 1.0 in float.
-     *  When desired_channels is set, if the input contains fewer channels than this
+     *
+     * When desired_channels is set, if the input contains fewer channels than this
      *  then the last channel will be duplicated to give the requested number, else if
      *  the input has more channels than requested then the additional channels will be
      *  ignored.
-     *  If desired_samples is set, then the audio will be cropped or padded with zeroes
+     *
+     * If desired_samples is set, then the audio will be cropped or padded with zeroes
      *  to the requested length.
-     *  The first output contains a Tensor with the content of the audio samples. The
+     *
+     * The first output contains a Tensor with the content of the audio samples. The
      *  lowest dimension will be the number of channels, and the second will be the
      *  number of samples. For example, a ten-sample-long stereo WAV file should give an
-     *  output shape of [10, 2].
+     *  output shape of [10, 2].
      *
      * @param contents The WAV-encoded audio, usually from a file.
      * @param options carries optional attribute values
@@ -141,10 +148,11 @@ public class AudioOps(
      *  audio file. It will be encoded in the 16-bit PCM format. It takes in float
      *  values in the range -1.0f to 1.0f, and any outside that value will be clamped to
      *  that range.
-     *  ``` audio``` is a 2-D float Tensor of shape ``` [length, channels]```.
-     *  ``` sample_rate``` is a scalar Tensor holding the rate to use (e.g. 44100).
      *
-     * @param audio 2-D with shape ` [length, channels]`.
+     * `audio` is a 2-D float Tensor of shape `[length, channels]`.
+     *  `sample_rate` is a scalar Tensor holding the rate to use (e.g. 44100).
+     *
+     * @param audio 2-D with shape `[length, channels]`.
      * @param sampleRate Scalar containing the sample frequency.
      * @return a new instance of EncodeWav
      * @see org.tensorflow.op.AudioOps.encodeWav

tensorflow-kotlin-parent/tensorflow-core-kotlin/src/gen/annotations/org/tensorflow/op/kotlin/BitwiseOps.kt

@@ -46,29 +46,31 @@ public class BitwiseOps(
     public val scope: Scope = ops.scope
 
     /**
-     * Elementwise computes the bitwise AND of ``` x``` and ``` y```.
-     *  The result will have those bits set, that are set in both ``` x``` and ``` y```. The
-     *  computation is performed on the underlying representations of ``` x``` and ``` y```.
-     *  For example:
+     * Elementwise computes the bitwise AND of `x` and `y`.
+     *  The result will have those bits set, that are set in both `x` and `y`. The
+     *  computation is performed on the underlying representations of `x` and `y`.
      *
-     *  import tensorflow as tf
+     * For example:
+     *  ```
+     * import tensorflow as tf
      *  from tensorflow.python.ops import bitwise_ops
-     *  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
+     *  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
      *                tf.uint8, tf.uint16, tf.uint32, tf.uint64]
      *
      *  for dtype in dtype_list:
-     *    lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
-     *    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
-     *    exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)
+     *    lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
+     *    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
+     *    exp = tf.constant([0, 0, 3, 10], dtype=tf.float32)
      *
      *    res = bitwise_ops.bitwise_and(lhs, rhs)
      *    tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE
      *
+     * ```
      *
-     * @param T data type for ` z` output
+     * @param <T> data type for `z` output
      * @param x the x value
      * @param y the y value
-     * @param T data type for ` BitwiseAnd` output and operands
+     * @param <T> data type for `BitwiseAnd` output and operands
      * @return a new instance of BitwiseAnd
      * @see org.tensorflow.op.BitwiseOps.bitwiseAnd
      */
@@ -79,29 +81,31 @@ public class BitwiseOps(
         )
 
     /**
-     * Elementwise computes the bitwise OR of ``` x``` and ``` y```.
-     *  The result will have those bits set, that are set in ``` x```, ``` y``` or both. The
-     *  computation is performed on the underlying representations of ``` x``` and ``` y```.
-     *  For example:
+     * Elementwise computes the bitwise OR of `x` and `y`.
+     *  The result will have those bits set, that are set in `x`, `y` or both. The
+     *  computation is performed on the underlying representations of `x` and `y`.
      *
-     *  import tensorflow as tf
+     * For example:
+     *  ```
+     * import tensorflow as tf
      *  from tensorflow.python.ops import bitwise_ops
-     *  dtype_list = &#91;tf.int8, tf.int16, tf.int32, tf.int64,
+     *  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
      *                tf.uint8, tf.uint16, tf.uint32, tf.uint64]
      *
      *  for dtype in dtype_list:
-     *    lhs = tf.constant(&#91;0, 5, 3, 14], dtype=dtype)
-     *    rhs = tf.constant(&#91;5, 0, 7, 11], dtype=dtype)
-     *    exp = tf.constant(&#91;5, 5, 7, 15], dtype=tf.float32)
+     *    lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
+     *    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
+     *    exp = tf.constant([5, 5, 7, 15], dtype=tf.float32)
      *
      *    res = bitwise_ops.bitwise_or(lhs, rhs)
      *    tf.assert_equal(tf.cast(res,  tf.float32), exp)  # TRUE
      *
+     * ```
      *
-     * @param T data type for ` z` output
+     * @param <T> data type for `z` output
      * @param x the x value
      * @param y the y value
-     * @param T data type for ` BitwiseOr` output and operands
+     * @param <T> data type for `BitwiseOr` output and operands
      * @return a new instance of BitwiseOr
      * @see org.tensorflow.op.BitwiseOps.bitwiseOr
      */
@@ -112,29 +116,31 @@ public class BitwiseOps(
         )
 
     /**
-     * Elementwise computes the bitwise XOR of ``` x``` and ``` y```.
-     *  The result will have those bits set, that are different in ``` x``` and ``` y```. The
-     *  computation is performed on the underlying representations of ``` x``` and ``` y```.
-     *  For example:
+     * Elementwise computes the bitwise XOR of `x` and `y`.
+     *  The result will have those bits set, that are different in `x` and `y`. The
+     *  computation is performed on the underlying representations of `x` and `y`.
      *
-     *  import tensorflow as tf
+     * For example:
+     *  ```
+     * import tensorflow as tf
      *  from tensorflow.python.ops import bitwise_ops
-     *  dtype_list = &#91;tf.int8, tf.int16, tf.int32, tf.int64,
+     *  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64,
      *                tf.uint8, tf.uint16, tf.uint32, tf.uint64]
      *
      *  for dtype in dtype_list:
-     *    lhs = tf.constant(&#91;0, 5, 3, 14], dtype=dtype)
-     *    rhs = tf.constant(&#91;5, 0, 7, 11], dtype=dtype)
-     *    exp = tf.constant(&#91;5, 5, 4, 5],  dtype=tf.float32)
+     *    lhs = tf.constant([0, 5, 3, 14], dtype=dtype)
+     *    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
+     *    exp = tf.constant([5, 5, 4, 5],  dtype=tf.float32)
      *
      *    res = bitwise_ops.bitwise_xor(lhs, rhs)
      *    tf.assert_equal(tf.cast(res, tf.float32), exp) # TRUE
      *
+     * ```
      *
-     * @param T data type for ` z` output
+     * @param <T> data type for `z` output
      * @param x the x value
      * @param y the y value
-     * @param T data type for ` BitwiseXor` output and operands
+     * @param <T> data type for `BitwiseXor` output and operands
      * @return a new instance of BitwiseXor
      * @see org.tensorflow.op.BitwiseOps.bitwiseXor
      */
@@ -145,51 +151,53 @@ public class BitwiseOps(
         )
 
     /**
-     * Invert (flip) each bit of supported types; for example, type ``` uint8``` value 01010101
-     * becomes 10101010.
-     *  Flip each bit of supported types.  For example, type ``` int8``` (decimal 2) binary 00000010
+     * Invert (flip) each bit of supported types; for example, type `uint8` value 01010101 becomes
+     * 10101010.
+     *  Flip each bit of supported types.  For example, type `int8` (decimal 2) binary 00000010
      * becomes (decimal -3) binary 11111101.
-     *  This operation is performed on each element of the tensor argument ``` x```.
-     *  Example:
+     *  This operation is performed on each element of the tensor argument `x`.
      *
-     *  import tensorflow as tf
+     * Example:
+     *  ```
+     * import tensorflow as tf
      *  from tensorflow.python.ops import bitwise_ops
      *
      *  # flip 2 (00000010) to -3 (11111101)
      *  tf.assert_equal(-3, bitwise_ops.invert(2))
      *
-     *  dtype_list = &#91;dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64,
+     *  dtype_list = [dtypes.int8, dtypes.int16, dtypes.int32, dtypes.int64,
      *                dtypes.uint8, dtypes.uint16, dtypes.uint32, dtypes.uint64]
      *
-     *  inputs = &#91;0, 5, 3, 14]
+     *  inputs = [0, 5, 3, 14]
      *  for dtype in dtype_list:
      *    # Because of issues with negative numbers, let's test this indirectly.
      *    # 1. invert(a) and a = 0
      *    # 2. invert(a) or a = invert(0)
-     *    input_tensor = tf.constant(&#91;0, 5, 3, 14], dtype=dtype)
-     *    not_a_and_a, not_a_or_a, not_0 = &#91;bitwise_ops.bitwise_and(
+     *    input_tensor = tf.constant([0, 5, 3, 14], dtype=dtype)
+     *    not_a_and_a, not_a_or_a, not_0 = [bitwise_ops.bitwise_and(
      *                                        input_tensor, bitwise_ops.invert(input_tensor)),
      *                                      bitwise_ops.bitwise_or(
      *                                        input_tensor, bitwise_ops.invert(input_tensor)),
      *                                      bitwise_ops.invert(
      *                                        tf.constant(0, dtype=dtype))]
      *
-     *    expected = tf.constant(&#91;0, 0, 0, 0], dtype=tf.float32)
+     *    expected = tf.constant([0, 0, 0, 0], dtype=tf.float32)
      *    tf.assert_equal(tf.cast(not_a_and_a, tf.float32), expected)
      *
-     *    expected = tf.cast(&#91;not_0] * 4, tf.float32)
+     *    expected = tf.cast([not_0] * 4, tf.float32)
      *    tf.assert_equal(tf.cast(not_a_or_a, tf.float32), expected)
      *
      *    # For unsigned dtypes let's also check the result directly.
      *    if dtype.is_unsigned:
      *      inverted = bitwise_ops.invert(input_tensor)
-     *      expected = tf.constant(&#91;dtype.max - x for x in inputs], dtype=tf.float32)
+     *      expected = tf.constant([dtype.max - x for x in inputs], dtype=tf.float32)
      *      tf.assert_equal(tf.cast(inverted, tf.float32), tf.cast(expected, tf.float32))
      *
+     * ```
      *
-     * @param T data type for ` y` output
+     * @param <T> data type for `y` output
      * @param x the x value
-     * @param T data type for ` Invert` output and operands
+     * @param <T> data type for `Invert` output and operands
      * @return a new instance of Invert
      * @see org.tensorflow.op.BitwiseOps.invert
      */
@@ -198,41 +206,42 @@ public class BitwiseOps(
     )
 
     /**
-     * Elementwise computes the bitwise left-shift of ``` x``` and ``` y```.
-     *  If ``` y``` is negative, or greater than or equal to the width of ``` x``` in bits the
+     * Elementwise computes the bitwise left-shift of `x` and `y`.
+     *  If `y` is negative, or greater than or equal to the width of `x` in bits the
      *  result is implementation defined.
-     *  Example:
      *
-     *  import tensorflow as tf
+     * Example:
+     *  ```
+     * import tensorflow as tf
      *  from tensorflow.python.ops import bitwise_ops
      *  import numpy as np
-     *  dtype_list = &#91;tf.int8, tf.int16, tf.int32, tf.int64]
+     *  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]
      *
      *  for dtype in dtype_list:
-     *    lhs = tf.constant(&#91;-1, -5, -3, -14], dtype=dtype)
-     *    rhs = tf.constant(&#91;5, 0, 7, 11], dtype=dtype)
+     *    lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)
+     *    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
      *
      *    left_shift_result = bitwise_ops.left_shift(lhs, rhs)
      *
      *    print(left_shift_result)
      *
      *  # This will print:
-     *  # tf.Tensor(&#91; -32   -5 -128    0], shape=(4,), dtype=int8)
-     *  # tf.Tensor(&#91;   -32     -5   -384 -28672], shape=(4,), dtype=int16)
-     *  # tf.Tensor(&#91;   -32     -5   -384 -28672], shape=(4,), dtype=int32)
-     *  # tf.Tensor(&#91;   -32     -5   -384 -28672], shape=(4,), dtype=int64)
+     *  # tf.Tensor([ -32   -5 -128    0], shape=(4,), dtype=int8)
+     *  # tf.Tensor([   -32     -5   -384 -28672], shape=(4,), dtype=int16)
+     *  # tf.Tensor([   -32     -5   -384 -28672], shape=(4,), dtype=int32)
+     *  # tf.Tensor([   -32     -5   -384 -28672], shape=(4,), dtype=int64)
      *
-     *  lhs = np.array(&#91;-2, 64, 101, 32], dtype=np.int8)
-     *  rhs = np.array(&#91;-1, -5, -3, -14], dtype=np.int8)
+     *  lhs = np.array([-2, 64, 101, 32], dtype=np.int8)
+     *  rhs = np.array([-1, -5, -3, -14], dtype=np.int8)
      *  bitwise_ops.left_shift(lhs, rhs)
-     *  # &lt;tf.Tensor: shape=(4,), dtype=int8, numpy=array(&#91; -2,  64, 101,  32],
-     * dtype=int8)&gt;
+     *  # <tf.Tensor: shape=(4,), dtype=int8, numpy=array([ -2,  64, 101,  32], dtype=int8)>
      *
+     * ```
      *
-     * @param T data type for ` z` output
+     * @param <T> data type for `z` output
      * @param x the x value
      * @param y the y value
-     * @param T data type for ` LeftShift` output and operands
+     * @param <T> data type for `LeftShift` output and operands
      * @return a new instance of LeftShift
      * @see org.tensorflow.op.BitwiseOps.leftShift
      */
@@ -243,43 +252,45 @@ public class BitwiseOps(
         )
 
     /**
-     * Elementwise computes the bitwise right-shift of ``` x``` and ``` y```.
+     * Elementwise computes the bitwise right-shift of `x` and `y`.
      *  Performs a logical shift for unsigned integer types, and an arithmetic shift
      *  for signed integer types.
-     *  If ``` y``` is negative, or greater than or equal to than the width of ``` x``` in bits
+     *
+     * If `y` is negative, or greater than or equal to than the width of `x` in bits
      *  the result is implementation defined.
-     *  Example:
      *
-     *  import tensorflow as tf
+     * Example:
+     *  ```
+     * import tensorflow as tf
      *  from tensorflow.python.ops import bitwise_ops
      *  import numpy as np
-     *  dtype_list = &#91;tf.int8, tf.int16, tf.int32, tf.int64]
+     *  dtype_list = [tf.int8, tf.int16, tf.int32, tf.int64]
      *
      *  for dtype in dtype_list:
-     *    lhs = tf.constant(&#91;-1, -5, -3, -14], dtype=dtype)
-     *    rhs = tf.constant(&#91;5, 0, 7, 11], dtype=dtype)
+     *    lhs = tf.constant([-1, -5, -3, -14], dtype=dtype)
+     *    rhs = tf.constant([5, 0, 7, 11], dtype=dtype)
      *
      *    right_shift_result = bitwise_ops.right_shift(lhs, rhs)
      *
      *    print(right_shift_result)
      *
      *  # This will print:
-     *  # tf.Tensor(&#91;-1 -5 -1 -1], shape=(4,), dtype=int8)
-     *  # tf.Tensor(&#91;-1 -5 -1 -1], shape=(4,), dtype=int16)
-     *  # tf.Tensor(&#91;-1 -5 -1 -1], shape=(4,), dtype=int32)
-     *  # tf.Tensor(&#91;-1 -5 -1 -1], shape=(4,), dtype=int64)
+     *  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int8)
+     *  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int16)
+     *  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int32)
+     *  # tf.Tensor([-1 -5 -1 -1], shape=(4,), dtype=int64)
      *
-     *  lhs = np.array(&#91;-2, 64, 101, 32], dtype=np.int8)
-     *  rhs = np.array(&#91;-1, -5, -3, -14], dtype=np.int8)
+     *  lhs = np.array([-2, 64, 101, 32], dtype=np.int8)
+     *  rhs = np.array([-1, -5, -3, -14], dtype=np.int8)
      *  bitwise_ops.right_shift(lhs, rhs)
-     *  # &lt;tf.Tensor: shape=(4,), dtype=int8, numpy=array(&#91; -2,  64, 101,  32],
-     * dtype=int8)&gt;
+     *  # <tf.Tensor: shape=(4,), dtype=int8, numpy=array([ -2,  64, 101,  32], dtype=int8)>
      *
+     * ```
      *
-     * @param T data type for ` z` output
+     * @param <T> data type for `z` output
      * @param x the x value
      * @param y the y value
-     * @param T data type for ` RightShift` output and operands
+     * @param <T> data type for `RightShift` output and operands
      * @return a new instance of RightShift
      * @see org.tensorflow.op.BitwiseOps.rightShift
      */