prometheus.io/scrape: "true"

  # Additional labels to apply on the pod level
  podLabels: {}

  # Pod resource configuration
  resources:
    requests:
      cpu: 200m
      # Ztunnel memory scales with the size of the cluster and traffic load
      # While there are many factors, this is enough for ~200k pod cluster or 100k concurrently open connections.
      memory: 512Mi

	if config.MaxPerCore != nil && *config.MaxPerCore > 0 {
		floor := 0
		if config.Min != nil {
			floor = int(*config.Min)
		}
		scaled := int(*config.MaxPerCore) * detectNumCPU()
		if scaled > floor {
			logger.V(3).Info("GetConntrackMax: using scaled conntrack-max-per-core")
			return scaled, nil
		}
		logger.V(3).Info("GetConntrackMax: using conntrack-min")
		return floor, nil
	}
	return 0, nil
}

MIN_COMBINED, a small bias is introduced where repeated iterations of quantizing
and dequantizing will introduce a larger and larger error.

*SCALED mode Example*

`SCALED` mode matches the quantization approach used in
`QuantizeAndDequantize{V2|V3}`.

If the mode is `SCALED`, the quantization is performed by multiplying each
input value by a scaling_factor.

        auto shape = GetAsVector(quant_tensor->shape());
        if (kUseUpdatedHybridSchemeDefault) {
          EXPECT_EQ(quant_tensor->quantization()->scale()->size(), shape[0]);
        } else {
          EXPECT_EQ(quant_tensor->quantization()->scale()->size(), 1);
        }
      } else {
        EXPECT_EQ(quant_tensor->type(), TensorType_FLOAT32);
      }
    }

			return false
		}
	case policy.WhenScaled == delete && policy.WhenDeleted == delete:
		podScaledDown := !podInOrdinalRange(pod, set)
		// If a pod is scaled down, there should be no set ref and a pod ref;
		// if the pod is not scaled down it's the other way around.
		if podScaledDown == hasOwnerRef(claim, set) {
			return false
		}
		if podScaledDown != hasOwnerRef(claim, pod) {
			return false
		}

    auto scaled = rewriter.create<chlo::BroadcastMulOp>(
        op.getLoc(), result_type, iota, op.getDelta(),
        hlo::getBroadcastDimensionsAttr(&rewriter, iota, op.getDelta()));
    rewriter.replaceOpWithNewOp<chlo::BroadcastAddOp>(
        op, result_type, scaled, op.getStart(),
        hlo::getBroadcastDimensionsAttr(&rewriter, scaled, op.getStart()));
    return success();
  }
};

							Ref:         ref("k8s.io/api/core/v1.PortworxVolumeSource"),
						},
					},
					"scaleIO": {
						SchemaProps: spec.SchemaProps{
							Description: "scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes.",
							Ref:         ref("k8s.io/api/core/v1.ScaleIOPersistentVolumeSource"),
						},
					},

    float_min = -float_max;
  }

  ASSERT_THAT(quantized_quant_params.scale, SizeIs(1));
  ASSERT_THAT(quantized_quant_params.zero_point, SizeIs(1));
  float scale = (float_max - float_min) / ((1 << bit_num) - 1);
  EXPECT_THAT(scale, FloatNear(quantized_quant_params.scale[0], eps));
}

class QuantizeModelTest : public testing::Test {
 protected:
  QuantizeModelTest() {

          },
          "scaleIO": {
            "allOf": [
              {
                "$ref": "#/components/schemas/io.k8s.api.core.v1.ScaleIOVolumeSource"
              }
            ],
            "description": "scaleIO represents a ScaleIO persistent volume attached and mounted on Kubernetes nodes."
          },
          "secret": {

      "properties": {
        "scale": {
          "$ref": "#/definitions/io.k8s.apiextensions-apiserver.pkg.apis.apiextensions.v1.CustomResourceSubresourceScale",
          "description": "scale indicates the custom resource should serve a `/scale` subresource that returns an `autoscaling/v1` Scale object."
        },
        "status": {