+
    åûj  ã                   óP   € ^ RI Ht ^ RIt^ RIHt  ! R R]P                  4      tR# )é    )ÚUnionN)Únnc                   óT   a a€ ] tR t^t oRtV3R lV 3R lltV3R lR ltRtVtV ;t	# )ÚRescaleaË  Multiply the input by a constant factor.

``op = Rescale(factor)`` stores ``factor`` and ``out = op(input)`` returns ``input * factor``. A tensor factor is
stored as a non-persistent buffer, so ``.to()`` moves it, and an ``nn.Parameter`` stays a parameter that optimizers
and checkpoints include.

Convention:
    A float factor is applied as a Python number: a float64 input keeps its precision and an integer input promotes
    to the default float dtype.

Args:
    factor: scaling factor, a ``float`` or a 0-d tensor. An ``int`` raises ``TypeError``.

Shape:
    - Input: any shape.
    - Output: same shape as the input.

See Also:
    - :class:`~kornia.geometry.transform.Rescale`: resizes an image by a factor instead of multiplying its values.
    - :func:`adjust_contrast`: multiplies an image by a factor and clamps it to :math:`[0, 1]`.

Example:
    >>> Rescale(0.5)(torch.ones(1, 1, 2, 2))
    tensor([[[[0.5000, 0.5000],
              [0.5000, 0.5000]]]])

c                óN   <€ V ^8„  d   QhRS[ S[S[P                  3,          RR/# )é   ÚfactorÚreturnN)r   ÚfloatÚtorchÚTensor)ÚformatÚ__classdict__s   "€ÚRC:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\kornia\enhance\rescale.pyÚ__annotate__ÚRescale.__annotate__5   s-   ø€ ÷ 
cñ 
c™u¡U©E¯L©LÐ%8Õ9ð 
c¸dñ 
có    c                óX  <€ \         SV `  4        \        V\        4      '       d	   Wn        R# \        V\
        P                  4      '       dP   VP                  ^ 8X  d?   \        V\        P                  4      '       d	   Wn        R# V P                  RVRR7       R# \        RV R24      h)r   r	   F)Ú
persistentz9Expected factor to be a float or a 0-d torch.Tensor, got Ú.N)ÚsuperÚ__init__Ú
isinstancer   r	   r   r   Úndimr   Ú	ParameterÚregister_bufferÚ	TypeError)Úselfr	   Ú	__class__s   &&€r   r   ÚRescale.__init__5   s   ø€ Ü‰ÑÔÜ�fœe×$Ò$Ø ŽKÜ˜¤§¡×-Ò-°&·+±+ÀÔ2BÜ˜&¤"§,¡,×/Ò/Ø$–à×$Ñ$ X¨vÀ%Ð$ÖHäÐWÐX^ÐW_Ð_`ÐaÓbÐbr   c                óN   <€ V ^8„  d   QhRS[ P                  RS[ P                  /# )r   Úinputr
   )r   r   )r   r   s   "€r   r   r   A   s#   ø€ ÷ #ñ #™UŸ\™\ð #©e¯l©lñ #r   c                ó&   € WP                   ,          # )a´  Multiply the input tensor by the configured scaling factor.

Args:
    input: Tensor to be rescaled. In image workflows this is commonly
        shaped as ``(*, C, H, W)``, where ``*`` denotes optional
        leading dimensions (for example batch), ``C`` is channel count,
        and ``H``/``W`` are spatial dimensions.

Returns:
    A tensor with the same shape as ``input``, where each element is
    multiplied by ``self.factor``.
©r	   )r   r"   s   &&r   ÚforwardÚRescale.forwardA   s   € ð —{‘{Õ"Ð"r   r$   )
Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__r   r%   Ú__static_attributes__Ú__classdictcell__Ú__classcell__)r   r   s   @@r   r   r      s%   ù‡ € ñ÷8
có 
c÷#÷ #ð #r   r   )Útypingr   r   r   ÚModuler   © r   r   Ú<module>r2      s    ðõ$ ã Ý ô8#ˆb�i‰iö 8#r   