
    [Th                     ,    S SK Jr  S SKr " S S5      rg)    )OptionalNc            	          \ rS rSrSrSrSrSS jr   SS\S\	\
R                     S	\	\
R                     S
\
R                  4S jjr  SS\S\	\
R                     S	\	\
R                     S
\
R                  4S jjrS rS rS rS rSrg)SobolEngine   a  
The :class:`torch.quasirandom.SobolEngine` is an engine for generating
(scrambled) Sobol sequences. Sobol sequences are an example of low
discrepancy quasi-random sequences.

This implementation of an engine for Sobol sequences is capable of
sampling sequences up to a maximum dimension of 21201. It uses direction
numbers from https://web.maths.unsw.edu.au/~fkuo/sobol/ obtained using the
search criterion D(6) up to the dimension 21201. This is the recommended
choice by the authors.

References:
  - Art B. Owen. Scrambling Sobol and Niederreiter-Xing points.
    Journal of Complexity, 14(4):466-489, December 1998.

  - I. M. Sobol. The distribution of points in a cube and the accurate
    evaluation of integrals.
    Zh. Vychisl. Mat. i Mat. Phys., 7:784-802, 1967.

Args:
    dimension (Int): The dimensionality of the sequence to be drawn
    scramble (bool, optional): Setting this to ``True`` will produce
                               scrambled Sobol sequences. Scrambling is
                               capable of producing better Sobol
                               sequences. Default: ``False``.
    seed (Int, optional): This is the seed for the scrambling. The seed
                          of the random number generator is set to this,
                          if specified. Otherwise, it uses a random seed.
                          Default: ``None``

Examples::

    >>> # xdoctest: +SKIP("unseeded random state")
    >>> soboleng = torch.quasirandom.SobolEngine(dimension=5)
    >>> soboleng.draw(3)
    tensor([[0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
            [0.5000, 0.5000, 0.5000, 0.5000, 0.5000],
            [0.7500, 0.2500, 0.2500, 0.2500, 0.7500]])
   iR  Nc                    XR                   :  d  US:  a  [        SU R                    S35      eX0l        X l        Xl        [
        R                  " S5      n[
        R                  " XR                  U[
        R                  S9U l
        [
        R                  " U R                  U R                  5        U R                  (       d4  [
        R                  " U R                  U[
        R                  S9U l        OU R                  5         U R                  R                  [
        R                  S9U l        U R                   SU R                  -  -  R#                  SS5      U l        S	U l        g )
N   z9Supported range of dimensionality for SobolEngine is [1, ]cpu)devicedtype)memory_format   r   )MAXDIM
ValueErrorseedscramble	dimensiontorchr   zerosMAXBITlong
sobolstate_sobol_engine_initialize_state_shift	_scrambleclonecontiguous_formatquasireshape_first_pointnum_generated)selfr   r   r   r   s        I/var/www/auris/envauris/lib/python3.13/site-packages/torch/quasirandom.py__init__SobolEngine.__init__3   s   {{"i!m**.++a9 
 	 "ll5!++{{3ejj
 	--doot~~N}}T^^CuzzRDJNNZZ%%E4K4K%L
!ZZ!T[[.8AA!RH    noutr   returnc           	         Uc  [         R                  " 5       nU R                  S:X  a  US:X  a  U R                  R	                  U5      nO[         R
                  " U R                  US-
  U R                  U R                  U R                  US9u  o@l        [         R                  " U R                  R	                  U5      U4SS9nOK[         R
                  " U R                  UU R                  U R                  U R                  S-
  US9u  o@l        U =R                  U-  sl        Ub"  UR                  U5      R                  U5        U$ U$ )a  
Function to draw a sequence of :attr:`n` points from a Sobol sequence.
Note that the samples are dependent on the previous samples. The size
of the result is :math:`(n, dimension)`.

Args:
    n (Int, optional): The length of sequence of points to draw.
                       Default: 1
    out (Tensor, optional): The output tensor
    dtype (:class:`torch.dtype`, optional): the desired data type of the
                                            returned tensor.
                                            Default: ``None``
r   r	   )r   )dim)r   get_default_dtyper#   r"   to_sobol_engine_drawr    r   r   cat
resize_as_copy_)r$   r)   r*   r   results        r%   drawSobolEngine.drawN   s   & =++-E"Av**--e4%*%=%=JJEOONN&&&"
 D$5$5$8$8$?#HbQ!&!9!9

""Q&"FJ 	a?NN6"((0Jr(   mc                     SU-  nU R                   U-   nXUS-
  -  S:X  d,  [        SU R                    SU R                    SU SU S3	5      eU R                  XBUS	9$ )
a  
Function to draw a sequence of :attr:`2**m` points from a Sobol sequence.
Note that the samples are dependent on the previous samples. The size
of the result is :math:`(2**m, dimension)`.

Args:
    m (Int): The (base2) exponent of the number of points to draw.
    out (Tensor, optional): The output tensor
    dtype (:class:`torch.dtype`, optional): the desired data type of the
                                            returned tensor.
                                            Default: ``None``
r   r	   r   zFThe balance properties of Sobol' points require n to be a power of 2. z0 points have been previously generated, then: n=z+2**=zH. If you still want to do this, please use 'SobolEngine.draw()' instead.)r)   r*   r   )r#   r   r6   )r$   r8   r*   r   r)   total_ns         r%   
draw_base2SobolEngine.draw_base2   s    $ qD$$q(Q;'1,))-););(< =1151C1C0DD1WI V00  yy1Uy33r(   c                 ^    U R                   R                  U R                  5        SU l        U $ )z6
Function to reset the ``SobolEngine`` to base state.
r   )r    r4   r   r#   )r$   s    r%   resetSobolEngine.reset   s'     	

$r(   c                 d   U R                   S:X  aF  [        R                  " U R                  US-
  U R                  U R
                  U R                   5        OD[        R                  " U R                  XR                  U R
                  U R                   S-
  5        U =R                   U-  sl         U $ )z
Function to fast-forward the state of the ``SobolEngine`` by
:attr:`n` steps. This is equivalent to drawing :attr:`n` samples
without using the samples.

Args:
    n (Int): The number of steps to fast-forward by.
r   r	   )r#   r   _sobol_engine_ff_r    r   r   )r$   r)   s     r%   fast_forwardSobolEngine.fast_forward   s     "##

AE4??DNNDDVDV ##

A@R@RUV@V 	ar(   c                    S nU R                   b0  [        R                  " 5       nUR                  U R                   5        [        R                  " S5      n[        R
                  " SU R                  U R                  4X!S9n[        R                  " U[        R                  " S[        R                  " SU R                  US95      5      U l        U R                  U R                  U R                  4n[        R
                  " SXBUS9R                  5       n[        R                  " U R                  XPR                  5        g )Nr   r   )r   	generatorr   )r   )r   r   	Generatormanual_seedr   randintr   r   mvpowaranger   tril_sobol_engine_scramble_r   )r$   gr   
shift_intsltm_dimsltms         r%   r   SobolEngine._scramble   s    '+99 !AMM$))$ll5! ]],S

 XX		!U\\!T[[%MN


 NNDKK=mmAxqAFFH%%doosNNKr(   c                     SU R                    3/nU R                  (       a  US/-  nU R                  b  USU R                   3/-  nU R                  R                  S-   SR                  U5      -   S-   $ )Nz
dimension=zscramble=Truezseed=(z, ))r   r   r   	__class____name__join)r$   
fmt_strings     r%   __repr__SobolEngine.__repr__   st    "4>>"234
==?++J99 U499+.//J~~&&,tyy/DDsJJr(   )r"   r   r#   r    r   r   r   r   )FN)r	   NN)NN)rX   
__module____qualname____firstlineno____doc__r   r   r&   intr   r   Tensorr   r6   r<   r?   rC   r   r[   __static_attributes__ r(   r%   r   r      s    &P FF: &*'+	33 ell#3 $	3
 
3p '+'+	44 ell#4 $	4
 
4<(L,Kr(   r   )typingr   r   r   rd   r(   r%   <module>rf      s     RK RKr(   