def testScalarMul(self):
   with self.test_session():
     values = constant_op.constant([2, 3, 5, 7], shape=[2, 2])
     indices = constant_op.constant([0, 2])
     x = math_ops.scalar_mul(-2, ops.IndexedSlices(values, indices))
     self.assertAllEqual(x.values.eval(), [[-4, -6], [-10, -14]])
     self.assertAllEqual(x.indices.eval(), [0, 2])

  def testAcceptsTensor(self):
    tensor = array_ops.ones([10, 10])
    result = math_ops.scalar_mul(3, tensor)
    expected = array_ops.ones([10, 10]) * 3

    with test_util.device(use_gpu=True):
      self.assertAllEqual(self.evaluate(expected), self.evaluate(result))

  def testAcceptsTensor(self):
    tensor = array_ops.ones([10, 10])
    result = math_ops.scalar_mul(3, tensor)
    expected = array_ops.ones([10, 10]) * 3

    with self.test_session(use_gpu=True):
      self.assertAllEqual(expected.eval(), result.eval())

 def testAcceptsIndexedSlices(self):
   values = constant_op.constant([2, 3, 5, 7, 0, -1], shape=[3, 2])
   indices = constant_op.constant([0, 2, 5])
   x = math_ops.scalar_mul(-3, ops.IndexedSlices(values, indices))
   with self.test_session(use_gpu=True):
     self.assertAllEqual(x.values.eval(), [[-6, -9], [-15, -21], [0, 3]])
     self.assertAllEqual(x.indices.eval(), [0, 2, 5])

 def testAcceptsRefs(self):
   var = variables.Variable(10)
   result = math_ops.scalar_mul(3, var)
   init = variables.global_variables_initializer()
   with self.test_session(use_gpu=True) as sess:
     sess.run(init)
     self.assertEqual(30, result.eval())

 def testAcceptsRefs(self):
   var = variables.Variable(10)
   result = math_ops.scalar_mul(3, var)
   init = variables.initialize_all_variables()
   with self.test_session() as sess:
     sess.run(init)
     self.assertEqual(30, result.eval())

def clip_norm(g, c, n):
  """Clip a tensor by norm.

  Arguments:
    g: gradient tensor to clip.
    c: clipping threshold.
    n: norm of gradient tensor.

  Returns:
    Clipped gradient tensor.
  """
  if c > 0:
    condition = n >= c
    then_expression = lambda: math_ops.scalar_mul(c / n, g)
    else_expression = lambda: g

    # saving the shape to avoid converting sparse tensor to dense
    if isinstance(g, ops.Tensor):
      g_shape = copy.copy(g.get_shape())
    elif isinstance(g, ops.IndexedSlices):
      g_shape = copy.copy(g.dense_shape)
    if condition.dtype != dtypes_module.bool:
      condition = math_ops.cast(condition, 'bool')
    g = control_flow_ops.cond(condition, then_expression, else_expression)
    if isinstance(g, ops.Tensor):
      g.set_shape(g_shape)
    elif isinstance(g, ops.IndexedSlices):
      g._dense_shape = g_shape  # pylint: disable=protected-access
  return g

 def testAcceptsRefs(self):
   if context.executing_eagerly():
     var = resource_variable_ops.ResourceVariable(10, name="var")
   else:
     var = variables.Variable(10)
   result = math_ops.scalar_mul(3, var)
   init = variables.global_variables_initializer()
   with test_util.device(use_gpu=True):
     self.evaluate(init)
     self.assertEqual(30, self.evaluate(result))

def _SquaredDifferenceGrad(op, grad):
  """Returns the gradient for (x-y)^2."""
  x = op.inputs[0]
  y = op.inputs[1]
  sx = array_ops.shape(x)
  sy = array_ops.shape(y)
  rx, ry = gen_array_ops.broadcast_gradient_args(sx, sy)
  with ops.control_dependencies([grad]):
    # The parens ensure that if grad is IndexedSlices, it'll get multiplied by
    # Tensor (not a number like 2.0) which causes it to convert to Tensor.
    x_grad = math_ops.scalar_mul(2.0, grad) * (x - y)
  return (array_ops.reshape(math_ops.reduce_sum(x_grad, rx), sx),
          -array_ops.reshape(math_ops.reduce_sum(x_grad, ry), sy))

 def testAcceptsConstant(self):
   const = constant_op.constant(10)
   result = math_ops.scalar_mul(3, const)
   with test_util.device(use_gpu=True):
     self.assertEqual(30, self.evaluate(result))

 def testAcceptsConstant(self):
   const = constant_op.constant(10)
   result = math_ops.scalar_mul(3, const)
   with self.test_session(use_gpu=True):
     self.assertEqual(30, result.eval())