class_docstr: Wrapper to convert from external to internal compressed representation.
  
  This may return either a Gaussian or a Gaussian + Tensor, where the Tensor
  represents byproducts of compression.
class_docstr_tok: ["Wrapper","to","convert","from","external","to","internal","compressed","representation",".","This","may","return","either","a","Gaussian","or","a","Gaussian","+","Tensor",",","where","the","Tensor","represents","byproducts","of","compression","."]
code: def __call__(
      cls,
      white_vec=None,
      prec_sqrt=None,
      inputs=None,
      *,
      mean=None,
      info_vec=None,
      precision=None,
      scale_tril=None,
      covariance=None,
  ):
      # Convert inputs.
      assert inputs is not None
      if isinstance(inputs, OrderedDict):
          inputs = tuple(inputs.items())
      assert isinstance(inputs, tuple)
  
      # Convert scale parameter to prec_sqrt.
      if prec_sqrt is None and white_vec is not None:
          raise ValueError("Cannot specify white_vec without prec_sqrt")
      if prec_sqrt is not None:
          is_tril = False
      elif precision is not None:
          prec_sqrt = ops.cholesky(precision)
          is_tril = True
      elif covariance is not None:
          prec_sqrt = _inverse_cholesky(covariance)
          is_tril = True
      elif scale_tril is not None:
          prec_sqrt = ops.transpose(
              ops.triangular_inv(scale_tril), -1, -2
          )
          is_tril = False
      else:
          raise ValueError(
              "At least one of prec_sqrt, precision, scale_tril, or covariance "
              "must be specified"
          )
  
      # Convert location parameter to white_vec.
      if white_vec is not None:
          pass
      elif mean is not None:
          white_vec = _vm(mean, prec_sqrt)
      elif info_vec is not None:
          if not is_tril:
              prec_sqrt = ops.cholesky(_mmt(prec_sqrt))  # triangularize
              is_tril = True
          white_vec = ops.triangular_solve(
              info_vec[..., None], prec_sqrt
          )[..., 0]
      else:
          raise ValueError(
              "At least one of white_vec, mean, or info_vec must be specified"
          )
  
      # Compress wide representations.
      shift = None
      dim, rank = prec_sqrt.shape[-2:]
      if rank > dim * cls.compression_threshold:
          white_vec, prec_sqrt, shift = _compress_rank(
              white_vec, prec_sqrt
          )
  
      # Create a Gaussian.
      result = super().__call__(white_vec, prec_sqrt, inputs)
  
      # Add compression byproducts.
      if shift is not None:
          int_inputs = OrderedDict(
              (k, v) for k, v in inputs if v.dtype != "real"
          )
          result += Tensor(shift, int_inputs)
  
      return result
  
imports: import math
  from collections import OrderedDict, defaultdict
  from contextlib import contextmanager
  from functools import reduce
  import funsor.ops
  from funsor.affine import affine_inputs, extract_affine, is_affine
  from funsor.delta import Delta
  from funsor.domains import Real, Reals
  from funsor.interpretations import compress_gaussians
  from funsor.ops import AddOp, SubOp
  from funsor.tensor import Tensor, align_tensor, align_tensors
  from funsor.terms import Binary, Funsor, FunsorMeta, Number, Slice, Subs, Variable, eager, reflect
  from funsor.util import broadcast_shape, get_tracing_state, lazy_property
label_desc: Use image node_id 1 for calling the GaussianMeta obj's underlying member method code with example usage: obj.__call__(cls, white_vec, prec_sqrt, inputs) and returns: result