diff --git a/tensorflow/lite/micro/kernels/activations_common.cc b/tensorflow/lite/micro/kernels/activations_common.cc
index c9e1d7de066..3a123e7464c 100644
--- a/tensorflow/lite/micro/kernels/activations_common.cc
+++ b/tensorflow/lite/micro/kernels/activations_common.cc
@@ -37,8 +37,8 @@ void CalculateReluOpData(const TfLiteTensor* input, TfLiteTensor* output,
                          ReluOpData* data) {
   float act_min = 0.0;
   float act_max = std::numeric_limits<float>::infinity();
-  double real_multiplier =
-      static_cast<double>(input->params.scale / output->params.scale);
+  double real_multiplier = static_cast<double>(input->params.scale) /
+                           static_cast<double>(output->params.scale);
 
   const RuntimeShape input_shape = GetTensorShape(input);
   const RuntimeShape output_shape = GetTensorShape(output);
diff --git a/tensorflow/lite/micro/kernels/cmsis_nn/svdf.cc b/tensorflow/lite/micro/kernels/cmsis_nn/svdf.cc
index d38aa81d18f..72458841256 100644
--- a/tensorflow/lite/micro/kernels/cmsis_nn/svdf.cc
+++ b/tensorflow/lite/micro/kernels/cmsis_nn/svdf.cc
@@ -148,20 +148,22 @@ TfLiteStatus CmsisNnPrepareSvdf(TfLiteContext* context, TfLiteNode* node) {
 
     TF_LITE_ENSURE_TYPES_EQ(context, output->type, kTfLiteInt8);
 
-    const double effective_scale_1 = static_cast<double>(
-        input->params.scale * weights_feature->params.scale /
-        activation_state->params.scale);
+    const double effective_scale_1 =
+        static_cast<double>(input->params.scale) *
+        static_cast<double>(weights_feature->params.scale) /
+        static_cast<double>(activation_state->params.scale);
     const double effective_scale_2 =
-        static_cast<double>(activation_state->params.scale *
-                            weights_time->params.scale / output->params.scale);
+        static_cast<double>(activation_state->params.scale) *
+        static_cast<double>(weights_time->params.scale) /
+        static_cast<double>(output->params.scale);
 
     // TODO(b/162018098): Use TF_LITE_ENSURE_NEAR when it is ready.
     // TODO(#1751): account for optional bias tensor
     TF_LITE_ENSURE(
         context,
         std::abs(static_cast<double>(bias->params.scale) -
-                 static_cast<double>(activation_state->params.scale *
-                                     weights_time->params.scale)) < 1e-5);
+                 (static_cast<double>(activation_state->params.scale) *
+                  static_cast<double>(weights_time->params.scale))) < 1e-5);
 
     QuantizeMultiplier(effective_scale_1, &(data->effective_scale_1_a),
                        &(data->effective_scale_1_b));
diff --git a/tensorflow/lite/micro/kernels/div.cc b/tensorflow/lite/micro/kernels/div.cc
index 7e64dc4c5cd..4b41e57e322 100644
--- a/tensorflow/lite/micro/kernels/div.cc
+++ b/tensorflow/lite/micro/kernels/div.cc
@@ -53,8 +53,9 @@ TfLiteStatus CalculateOpDataDiv(TfLiteContext* context, TfLiteTensor* input1,
     TF_LITE_ENSURE_STATUS(CalculateActivationRangeQuantized(
         context, params->activation, output, &data->output_activation_min,
         &data->output_activation_max));
-    const double real_multiplier = static_cast<double>(
-        input1->params.scale / (input2->params.scale * output->params.scale));
+    const double real_multiplier = static_cast<double>(input1->params.scale) /
+                                   (static_cast<double>(input2->params.scale) *
+                                    static_cast<double>(output->params.scale));
     QuantizeMultiplier(real_multiplier, &data->output_multiplier,
                        &data->output_shift);
     data->input1_zero_point = input1->params.zero_point;
diff --git a/tensorflow/lite/micro/kernels/elementwise.cc b/tensorflow/lite/micro/kernels/elementwise.cc
index ebfbdbe48b7..c1ef69e8b87 100644
--- a/tensorflow/lite/micro/kernels/elementwise.cc
+++ b/tensorflow/lite/micro/kernels/elementwise.cc
@@ -62,15 +62,16 @@ bool IsRsqrtSupportedType(const TfLiteType type) {
 inline void SetAbsOutputMultiplier(const float input_scale,
                                    const float output_scale,
                                    int32_t* multiplier, int* shift) {
-  QuantizeMultiplier(static_cast<double>(input_scale / output_scale),
-                     multiplier, shift);
+  QuantizeMultiplier(
+      static_cast<double>(input_scale) / static_cast<double>(output_scale),
+      multiplier, shift);
 }
 
 inline void SetRsqrtOutputMultiplier(const float input_scale,
                                      const float output_scale,
                                      int32_t* multiplier, int* shift) {
-  const double scale =
-      1. / static_cast<double>((std::sqrt(input_scale) * output_scale));
+  const double scale = 1.0 / (std::sqrt(static_cast<double>(input_scale)) *
+                              static_cast<double>(output_scale));
   QuantizeMultiplier(scale, multiplier, shift);
 }
 
diff --git a/tensorflow/lite/micro/kernels/hard_swish_common.cc b/tensorflow/lite/micro/kernels/hard_swish_common.cc
index cc0e5d2b8aa..0146f405638 100644
--- a/tensorflow/lite/micro/kernels/hard_swish_common.cc
+++ b/tensorflow/lite/micro/kernels/hard_swish_common.cc
@@ -55,8 +55,8 @@ TfLiteStatus HardSwishPrepare(TfLiteContext* context, TfLiteNode* node) {
     const float reluish_scale = 3.0f / 32768.0f;
     const float output_scale = output->params.scale;
 
-    const double output_multiplier =
-        static_cast<double>(hires_input_scale / output_scale);
+    const double output_multiplier = static_cast<double>(hires_input_scale) /
+                                     static_cast<double>(output_scale);
     int32_t output_multiplier_fixedpoint_int32;
     QuantizeMultiplier(output_multiplier, &output_multiplier_fixedpoint_int32,
                        &params->output_multiplier_exponent);
@@ -66,8 +66,8 @@ TfLiteStatus HardSwishPrepare(TfLiteContext* context, TfLiteNode* node) {
 
     TF_LITE_ENSURE(context, params->output_multiplier_exponent <= 0);
 
-    const double reluish_multiplier =
-        static_cast<double>(hires_input_scale / reluish_scale);
+    const double reluish_multiplier = static_cast<double>(hires_input_scale) /
+                                      static_cast<double>(reluish_scale);
     int32_t reluish_multiplier_fixedpoint_int32;
     QuantizeMultiplier(reluish_multiplier, &reluish_multiplier_fixedpoint_int32,
                        &params->reluish_multiplier_exponent);
diff --git a/tensorflow/lite/micro/kernels/kernel_util.cc b/tensorflow/lite/micro/kernels/kernel_util.cc
index 7c3cfbe46b9..3326224ea0f 100644
--- a/tensorflow/lite/micro/kernels/kernel_util.cc
+++ b/tensorflow/lite/micro/kernels/kernel_util.cc
@@ -578,8 +578,8 @@ TfLiteStatus GetQuantizedConvolutionMultipler(TfLiteContext* context,
                                               const TfLiteTensor* filter,
                                               TfLiteTensor* output,
                                               double* multiplier) {
-  const double input_product_scale =
-      static_cast<double>(input->params.scale * filter->params.scale);
+  const double input_product_scale = static_cast<double>(input->params.scale) *
+                                     static_cast<double>(filter->params.scale);
   TF_LITE_ENSURE(context, input_product_scale >= 0);
   *multiplier = input_product_scale / static_cast<double>(output->params.scale);
 
diff --git a/tensorflow/lite/micro/kernels/leaky_relu_common.cc b/tensorflow/lite/micro/kernels/leaky_relu_common.cc
index 16423224a0f..9831aaa7f36 100644
--- a/tensorflow/lite/micro/kernels/leaky_relu_common.cc
+++ b/tensorflow/lite/micro/kernels/leaky_relu_common.cc
@@ -50,15 +50,16 @@ TfLiteStatus CalculateOpDataLeakyRelu(TfLiteContext* context,
     data->output_zero_point = output->params.zero_point;
 
     int output_shift_alpha;
-    double alpha_multiplier = static_cast<double>(
-        input->params.scale * params->alpha / output->params.scale);
+    double alpha_multiplier = static_cast<double>(input->params.scale) *
+                              static_cast<double>(params->alpha) /
+                              static_cast<double>(output->params.scale);
     QuantizeMultiplier(alpha_multiplier, &data->output_multiplier_alpha,
                        &output_shift_alpha);
     data->output_shift_alpha = static_cast<int32_t>(output_shift_alpha);
 
     int output_shift_identity;
-    double identity_multiplier =
-        static_cast<double>(input->params.scale / output->params.scale);
+    double identity_multiplier = static_cast<double>(input->params.scale) /
+                                 static_cast<double>(output->params.scale);
     QuantizeMultiplier(identity_multiplier, &data->output_multiplier_identity,
                        &output_shift_identity);
     data->output_shift_identity = static_cast<int32_t>(output_shift_identity);
diff --git a/tensorflow/lite/micro/kernels/pooling_common.cc b/tensorflow/lite/micro/kernels/pooling_common.cc
index f734f899abc..1d6f15d72a8 100644
--- a/tensorflow/lite/micro/kernels/pooling_common.cc
+++ b/tensorflow/lite/micro/kernels/pooling_common.cc
@@ -67,8 +67,9 @@ TfLiteStatus PoolingPrepare(TfLiteContext* context, TfLiteNode* node) {
 
   // check if input, output quantization params are same.
   if (input->type == kTfLiteInt8 || input->type == kTfLiteInt16) {
-    const double scale_diff = static_cast<double>(
-        std::abs(input->params.scale - output->params.scale));
+    const double scale_diff =
+        std::abs(static_cast<double>(input->params.scale) -
+                 static_cast<double>(output->params.scale));
     TF_LITE_ENSURE(context, scale_diff <= 1.0e-6);
     TF_LITE_ENSURE(context,
                    input->params.zero_point == output->params.zero_point);
diff --git a/tensorflow/lite/micro/kernels/squared_difference.cc b/tensorflow/lite/micro/kernels/squared_difference.cc
index 42467631dc3..f109edc9d32 100644
--- a/tensorflow/lite/micro/kernels/squared_difference.cc
+++ b/tensorflow/lite/micro/kernels/squared_difference.cc
@@ -67,8 +67,8 @@ void PrepareQuantized(
       twice_max_input_scale;
   const double real_output_multiplier =
       (twice_max_input_scale * twice_max_input_scale) /
-      static_cast<double>((1 << data->arithmetic_params.left_shift * 2) *
-                          output_quantization_params.scale);
+      (static_cast<double>(1 << data->arithmetic_params.left_shift * 2) *
+       static_cast<double>(output_quantization_params.scale));
   QuantizeMultiplierSmallerThanOneExp(
       real_input1_multiplier, &data->arithmetic_params.input1_multiplier,
       &data->arithmetic_params.input1_shift);
diff --git a/tensorflow/lite/micro/kernels/sub_common.cc b/tensorflow/lite/micro/kernels/sub_common.cc
index 9db473ed71d..2534b040630 100644
--- a/tensorflow/lite/micro/kernels/sub_common.cc
+++ b/tensorflow/lite/micro/kernels/sub_common.cc
@@ -48,15 +48,16 @@ TfLiteStatus CalculateOpDataSub(TfLiteContext* context, TfLiteSubParams* params,
     // accordingly. In case of 16-bit we have 65535 << 15 which is less than 1
     // << 31, therefore the addition will still fit in a 32 bit accumulator.
     data->left_shift = output->type == kTfLiteInt16 ? 15 : 20;
-    const float twice_max_input_scale =
-        2 * std::max(input1->params.scale, input2->params.scale);
+    const double twice_max_input_scale =
+        2 * static_cast<double>(
+                std::max(input1->params.scale, input2->params.scale));
     const double real_input1_multiplier =
-        static_cast<double>(input1->params.scale / twice_max_input_scale);
+        static_cast<double>(input1->params.scale) / twice_max_input_scale;
     const double real_input2_multiplier =
-        static_cast<double>(input2->params.scale / twice_max_input_scale);
+        static_cast<double>(input2->params.scale) / twice_max_input_scale;
     const double real_output_multiplier =
-        static_cast<double>(twice_max_input_scale /
-                            ((1 << data->left_shift) * output->params.scale));
+        twice_max_input_scale / (static_cast<double>(1 << data->left_shift) *
+                                 static_cast<double>(output->params.scale));
 
     QuantizeMultiplierSmallerThanOneExp(
         real_input1_multiplier, &data->input1_multiplier, &data->input1_shift);
diff --git a/tensorflow/lite/micro/kernels/svdf_common.cc b/tensorflow/lite/micro/kernels/svdf_common.cc
index 5a15db7d280..4f7bc843c69 100644
--- a/tensorflow/lite/micro/kernels/svdf_common.cc
+++ b/tensorflow/lite/micro/kernels/svdf_common.cc
@@ -451,20 +451,22 @@ TfLiteStatus PrepareSvdf(TfLiteContext* context, TfLiteNode* node) {
 
     TF_LITE_ENSURE_TYPES_EQ(context, output->type, kTfLiteInt8);
 
-    const double effective_scale_1 = static_cast<double>(
-        input->params.scale * weights_feature->params.scale /
-        activation_state->params.scale);
+    const double effective_scale_1 =
+        static_cast<double>(input->params.scale) *
+        static_cast<double>(weights_feature->params.scale) /
+        static_cast<double>(activation_state->params.scale);
     const double effective_scale_2 =
-        static_cast<double>(activation_state->params.scale *
-                            weights_time->params.scale / output->params.scale);
+        static_cast<double>(activation_state->params.scale) *
+        static_cast<double>(weights_time->params.scale) /
+        static_cast<double>(output->params.scale);
 
     // TODO(b/162018098): Use TF_LITE_ENSURE_NEAR when it is ready.
     // TODO(#1751): account for optional bias tensor
     TF_LITE_ENSURE(
         context,
         std::abs(static_cast<double>(bias->params.scale) -
-                 static_cast<double>(activation_state->params.scale *
-                                     weights_time->params.scale)) < 1e-5);
+                 (static_cast<double>(activation_state->params.scale) *
+                  static_cast<double>(weights_time->params.scale))) < 1e-5);
 
     QuantizeMultiplier(effective_scale_1, &(data->effective_scale_1_a),
                        &(data->effective_scale_1_b));
diff --git a/tensorflow/lite/micro/kernels/xtensa/svdf.cc b/tensorflow/lite/micro/kernels/xtensa/svdf.cc
index 29f2fe87e13..d4ef9675b3a 100644
--- a/tensorflow/lite/micro/kernels/xtensa/svdf.cc
+++ b/tensorflow/lite/micro/kernels/xtensa/svdf.cc
@@ -200,16 +200,18 @@ TfLiteStatus PrepareInt8(TfLiteContext* context, TfLiteNode* node) {
   TF_LITE_ENSURE_TYPES_EQ(context, output->type, kTfLiteInt8);
 
   const double effective_scale_1 =
-      static_cast<double>(input->params.scale * weights_feature->params.scale /
-                          activation_state->params.scale);
+      static_cast<double>(input->params.scale) *
+      static_cast<double>(weights_feature->params.scale) /
+      static_cast<double>(activation_state->params.scale);
   const double effective_scale_2 =
-      static_cast<double>(activation_state->params.scale *
-                          weights_time->params.scale / output->params.scale);
+      static_cast<double>(activation_state->params.scale) *
+      static_cast<double>(weights_time->params.scale) /
+      static_cast<double>(output->params.scale);
 
   // TODO(#1751): account for optional bias tensor
   TF_LITE_ENSURE_NEAR(context, static_cast<double>(bias->params.scale),
-                      static_cast<double>(activation_state->params.scale *
-                                          weights_time->params.scale),
+                      (static_cast<double>(activation_state->params.scale) *
+                       static_cast<double>(weights_time->params.scale)),
                       1e-5);
 
   TFLITE_DCHECK(node->user_data != nullptr);