vectorwaves 1.0.0__py3-none-any.whl

vectorwaves/spectra.py

@@ -0,0 +1,341 @@
+"""
+KSpace and Polychromatic Spectras
+========================
+
+Mathematical implementations of spatial (k-space) and spectral (wavelength) distributions.
+All methods are implemented with xy plane as transverse plane!
+"""
+import numpy as np
+from scipy.special import eval_hermite, eval_genlaguerre
+
+class KSpaceSpectra:
+    """
+    Implementations of Spatial Profiles in k-space.
+    
+    All functions here take a k-vector array (shape: 3 x N) and spatial parameters, 
+    returning the complex amplitude of the field in k-space.
+    """
+
+    @staticmethod
+    def uniform(k_vec: np.ndarray, **kwargs) -> np.ndarray:
+        """
+        Flat angular spectrum (Uniform k-space).
+        
+        Weights all plane wave directions equally. Physically, if the modes are 
+        coherent (locked phase), this corresponds to an infinitesimally small 
+        point source or a perfectly spherical converging wave. If phases are 
+        random, this simulates isotropic diffuse light.
+
+        Formula:
+            S(k) = 1.0 + 0j
+
+        Parameters
+        ----------
+        k_vec : np.ndarray
+            Array of k-vectors of shape (3, N) or (3,).
+            
+        Returns
+        -------
+        np.ndarray
+            Array of ones matching the length of the input k-vectors.
+        """
+        if k_vec.ndim == 1:
+            return 1.0 + 0j
+        return np.ones(k_vec.shape[1], dtype=complex)
+
+    @staticmethod
+    def gaussian(k_vec: np.ndarray, sigma_k_perp: float) -> np.ndarray:
+        """
+        Gaussian spatial profile in k-space.
+
+        Mathematically defines a fundamental Gaussian beam (TEM00).
+
+        Formula:
+            S(kx, ky) = exp( -(kx^2 + ky^2) / (2 * sigma_k_perp^2) )
+
+        Parameters
+        ----------
+        k_vec : np.ndarray
+            Array of k-vectors of shape (3, N) where rows are kx, ky, kz.
+        sigma_k_perp : float
+            The standard deviation of the Gaussian envelope in k-space.
+            This is inversely proportional to the real-space beam waist (w0).
+
+        Returns
+        -------
+        np.ndarray
+            Complex amplitude weights for each plane wave mode.
+        """
+        kx, ky = k_vec[0], k_vec[1]
+        gaussian_profile = np.exp(-(kx**2 + ky**2) / (2 * sigma_k_perp**2))
+        return gaussian_profile.astype(complex)
+
+    @staticmethod
+    def tophat(k_vec: np.ndarray, k_perp_max: float) -> np.ndarray:
+        """
+        Uniform Top-Hat disk spectrum.
+
+        Defines a sharp cutoff in transverse momentum. In real space, 
+        this produces a J1(r)/r (Airy disk) transverse profile.
+
+        Formula:
+            S(kx, ky) = 1.0   if (kx^2 + ky^2) <= k_perp_max^2
+            S(kx, ky) = 0.0   otherwise
+
+        Parameters
+        ----------
+        k_vec : np.ndarray
+            Array of k-vectors of shape (3, N).
+        k_perp_max : float
+            The maximum transverse spatial frequency allowed.
+
+        Returns
+        -------
+        np.ndarray
+            Complex amplitude weights (1.0 or 0.0).
+        """
+        mask = (k_vec[0]**2 + k_vec[1]**2) < k_perp_max**2
+        return mask.astype(complex)
+
+    @staticmethod
+    def laguerre_gauss(k_vec: np.ndarray, p: int, l: int, sigma_k_perp: float) -> np.ndarray:
+        """
+        Angular spectrum for Laguerre-Gauss (Vortex) modes.
+
+        Defines a beam carrying Orbital Angular Momentum (OAM). 
+        The parameter `l` defines the topological charge, and `p` defines 
+        the number of radial nodes.
+
+        Formula:
+            rho^2 = kx^2 + ky^2
+            phi_k = arctan2(ky, kx)
+            X = rho^2 / sigma_k_perp^2
+            
+            S(kx, ky) = X^(|l|/2) * L_p^{|l|}(X) * exp(-X/2) * exp(i * l * phi_k)
+
+        Parameters
+        ----------
+        k_vec : np.ndarray
+            Array of k-vectors of shape (3, N).
+        p : int
+            Radial index (p >= 0). Determines the number of radial rings.
+        l : int
+            Azimuthal index (topological charge). Determines OAM.
+        sigma_k_perp : float
+            Transverse scaling parameter in k-space.
+
+        Returns
+        -------
+        np.ndarray
+            Complex amplitude weights defining the LG mode.
+        """
+        kx, ky = k_vec[0], k_vec[1]
+        k_perp_sq = kx**2 + ky**2
+        phi = np.arctan2(ky, kx)
+        
+        X = k_perp_sq / (sigma_k_perp**2)
+        poly_val = eval_genlaguerre(p, abs(l), X)
+        gaussian_env = np.exp(-0.5 * X)
+        radial = (np.sqrt(X)) ** abs(l)
+        vortex = np.exp(1j * l * phi)
+    
+        res = (radial * poly_val * gaussian_env * vortex).astype(complex)
+        res = np.where(k_perp_sq == 0, 0j, res)
+        return res if res.size > 1 else res[0]
+    
+    @staticmethod
+    def hermite_gauss(k_vec: np.ndarray, l: int, m: int, sigma_k_perp: float) -> np.ndarray:
+        """
+        Angular spectrum for Hermite-Gauss modes.
+
+        Defines higher-order transverse modes in Cartesian coordinates, 
+        often seen emitted by laser cavities breaking cylindrical symmetry.
+
+        Formula:
+            scale = sqrt(2) / sigma_k_perp
+            S(kx, ky) = H_l(kx * scale) * H_m(ky * scale) * exp(-(kx^2 + ky^2) / 2 sigma_k_perp^2)
+
+        Parameters
+        ----------
+        k_vec : np.ndarray
+            Array of k-vectors of shape (3, N).
+        l : int
+            Transverse mode index in the x-direction (l >= 0).
+        m : int
+            Transverse mode index in the y-direction (m >= 0).
+        sigma_k_perp : float
+            Transverse scaling parameter in k-space.
+
+        Returns
+        -------
+        np.ndarray
+            Complex amplitude weights defining the HG mode.
+        """
+        kx, ky = k_vec[0], k_vec[1]
+        
+        # Dimensionless scaling: x / (w0_k / sqrt(2)) -> x * sqrt(2) / sigma
+        scale = np.sqrt(2) / sigma_k_perp
+        
+        term_x = eval_hermite(l, kx * scale)
+        term_y = eval_hermite(m, ky * scale)
+        gaussian = np.exp(-(kx**2 + ky**2) / (2 * sigma_k_perp**2))
+        
+        res = (term_x * term_y * gaussian).astype(complex)
+        return res
+
+    @staticmethod
+    def bessel_gauss(k_vec: np.ndarray, theta_0: float, sigma_theta: float, l: int = 0) -> np.ndarray:
+        """
+        Angular spectrum for a Bessel-Gauss beam.
+
+        Defined by a Gaussian ring of illumination on the angular hemisphere.
+        Creates a "non-diffracting" Bessel beam core in real space, enveloped
+        by a Gaussian bounds.
+
+        Formula:
+            theta_k = arccos(kz / |k|)
+            phi_k = arctan2(ky, kx)
+            
+            S(k) = exp( -(theta_k - theta_0)^2 / (2 * sigma_theta^2) ) * exp(i * l * phi_k)
+
+        Parameters
+        ----------
+        k_vec : np.ndarray
+            Array of k-vectors of shape (3, N) where rows are kx, ky, kz.
+        theta_0 : float
+            Cone opening angle (in radians) of the Bessel beam in k-space.
+        sigma_theta : float
+            Angular thickness (in radians) of the Gaussian ring.
+        l : int, optional
+            Topological charge. If l != 0, creates a Higher-Order Bessel beam (vortex).
+
+        Returns
+        -------
+        np.ndarray
+            Complex amplitude weights defining the BG mode.
+        """
+        # Extract components - each has shape (N,)
+        kx, ky, kz = k_vec[0], k_vec[1], k_vec[2]
+        k_mag = np.sqrt(kx**2 + ky**2 + kz**2)
+        res = np.zeros_like(k_mag, dtype=complex)
+        mask = k_mag > 0
+        
+        theta = np.zeros_like(k_mag)
+        theta[mask] = np.arccos(np.clip(kz[mask] / k_mag[mask], -1, 1))
+        
+        diff = theta - theta_0
+        ring_profile = np.exp(-(diff**2) / (2 * sigma_theta**2))
+        
+        if l != 0:
+            phi = np.arctan2(ky, kx)  # shape (N,)
+            vortex = np.exp(1j * l * phi)  # shape (N,)
+            res[mask] = (ring_profile[mask] * vortex[mask])
+        else:
+            res[mask] = ring_profile[mask]
+        
+        return res
+
+class PolychromaticSpectra:
+    """
+    Implementations of Polychromatic Envelopes.
+    
+    All functions here take a wavelength and spectral parameters, 
+    returning a real scalar weight for that specific wavelength.
+    """
+
+    @staticmethod
+    def uniform(wavelength: float, **kwargs) -> float:
+        """
+        Flat spectral envelope. 
+
+        Formula:
+            F(lambda) = 1.0
+
+        Parameters
+        ----------
+        wavelength : float
+            The wavelength to evaluate.
+            
+        Returns
+        -------
+        float
+            Weight of 1.0 for all inputs.
+        """
+        return 1.0
+
+    @staticmethod
+    def gaussian(wl: float, center: float, sigma: float) -> float:
+        """
+        Gaussian spectral weight distribution.
+        
+        Formula:
+            F(lambda) = exp( -(lambda - center)^2 / (2 * sigma^2) )
+
+        Parameters
+        ----------
+        wl : float
+            The wavelength to evaluate.
+        center : float
+            The central wavelength (mean).
+        sigma : float
+            The spectral bandwidth (standard deviation).
+
+        Returns
+        -------
+        float
+            Real scalar weight for the given wavelength.
+        """
+        return float(np.exp(-(wl - center)**2 / (2 * sigma**2)))
+
+    @staticmethod
+    def lorentzian(wl: float, center: float, gamma: float) -> float:
+        """
+        Lorentzian spectral weight distribution.
+        
+        Often models natural line-broadening in atomic emission.
+
+        Formula:
+            F(lambda) = gamma^2 / ( (lambda - center)^2 + gamma^2 )
+
+        Parameters
+        ----------
+        wl : float
+            The wavelength to evaluate.
+        center : float
+            The central resonance wavelength.
+        gamma : float
+            The Half-Width at Half-Maximum (HWHM) of the spectrum.
+
+        Returns
+        -------
+        float
+            Real scalar weight for the given wavelength.
+        """
+        return float(gamma**2 / ((wl - center)**2 + gamma**2))
+
+    @staticmethod
+    def tophat(wl: float, center: float, width: float) -> float:
+        """
+        Top-hat (Rectangular) spectral weight distribution.
+
+        Idealized bandpass filter.
+
+        Formula:
+            F(lambda) = 1.0  if |lambda - center| <= width / 2
+            F(lambda) = 0.0  otherwise
+
+        Parameters
+        ----------
+        wl : float
+            The wavelength to evaluate.
+        center : float
+            The central wavelength of the bandpass.
+        width : float
+            The total spectral width of the bandpass.
+
+        Returns
+        -------
+        float
+            Real scalar weight (1.0 or 0.0).
+        """
+        return 1.0 if abs(wl - center) <= width / 2 else 0.0

vectorwaves/utils.py

@@ -0,0 +1,130 @@
+"""
+Utility Functions
+=================
+
+Miscellaneous helper functions for calculating optical properties,
+polarization ellipses, and basis transformations.
+"""
+from typing import Dict, Union, Tuple
+import numpy as np
+
+def get_stokes_params(E1: np.ndarray, E2: np.ndarray, normalize: bool = False) -> Dict[str, np.ndarray]:
+    """
+    Computes Stokes parameters from two orthogonal electric field components.
+    
+    For a beam propagating along the Z-axis, you can pass `FieldResult.E[0]` (Ex) 
+    and `FieldResult.E[1]` (Ey) to calculate the transverse Stokes parameters.
+
+    Parameters
+    ----------
+    E1, E2 : np.ndarray
+        Complex electric field components of the same shape.
+    normalize : bool, optional
+        If True, returns the normalized Stokes parameters (s1, s2, s3) where 
+        s_i = S_i / S0. Defaults to False.
+
+    Returns
+    -------
+    dict 
+        - If normalize=True:  {'S0': ..., 's1': ..., 's2': ..., 's3': ...}
+        - If normalize=False: {'S0': ..., 'S1': ..., 'S2': ..., 'S3': ...}
+    """    
+    I1 = np.abs(E1)**2
+    I2 = np.abs(E2)**2
+    
+    S0 = I1 + I2
+    S1 = I1 - I2
+    
+    # Calculate cross term
+    cross_term = E1 * np.conj(E2)
+    S2 = 2 * np.real(cross_term)
+    S3 = 2 * np.imag(cross_term)
+    
+    if normalize:
+        denom = np.where(S0 == 0, 1.0, S0)
+        return {'S0': S0, 's1': S1/denom, 's2': S2/denom, 's3': S3/denom}
+        
+    return {'S0': S0, 'S1': S1, 'S2': S2, 'S3': S3}
+
+def get_pol_ellipse_params(E1: np.ndarray, E2: np.ndarray) -> Dict[str, np.ndarray]:
+    """
+    Calculates the geometric properties of the polarization ellipse
+    formed by two orthogonal electric field components.
+
+    Parameters
+    ----------
+    E1, E2 : np.ndarray
+        Complex electric field components of the same shape.
+        
+    Returns
+    -------
+    dict 
+        Dictionary containing arrays of the same shape as inputs:
+        - 'psi': Orientation angle in[-pi/2, pi/2]
+        - 'chi': Ellipticity angle in [-pi/4, pi/4]
+        - 'delta': Phase difference (phi_2 - phi_1) in range [-pi, pi]
+        - 'a': Semi-major axis length (normalized to local intensity)
+        - 'b': Semi-minor axis length (normalized to local intensity)
+        - 'handedness': +1 for LCP/CCW, -1 for RCP/CW (based on S3 sign)
+    """
+    stokes = get_stokes_params(E1, E2, normalize=True)
+    S0, s1, s2, s3 = stokes['S0'], stokes['s1'], stokes['s2'], stokes['s3']
+    
+    # 1. Orientation Angle (Psi)
+    psi = 0.5 * np.arctan2(s2, s1)
+    
+    # 2. Ellipticity Angle (Chi)
+    s3_norm = np.clip(s3, -1.0, 1.0)
+    chi = 0.5 * np.arcsin(s3_norm)
+    
+    # 3. Phase Difference (Delta)
+    delta = np.angle(E2 * np.conj(E1))
+    
+    # 4. Geometry for Plotting (Semi-axes)
+    amp = np.sqrt(S0)
+    a = amp * np.cos(chi)
+    b = amp * np.abs(np.sin(chi))
+    
+    return {
+        'psi': psi, 
+        'chi': chi, 
+        'delta': delta,
+        'a': a, 
+        'b': b,
+        'handedness': np.sign(s3)
+    }
+
+def decompose_in_basis(E1: np.ndarray, E2: np.ndarray, u: Union[Tuple[complex, complex], np.ndarray]) -> Dict[str, np.ndarray]:
+    """
+    Decomposes a 2-component complex field (E1, E2) into an orthonormal 
+    polarization basis defined by the reference vector `u`.
+
+    Parameters
+    ----------
+    E1, E2 : np.ndarray
+        Complex arrays representing the field in the original basis.
+    u : tuple or np.ndarray
+        Reference vector (2,) defining the first new basis vector (in the same plane).
+        
+    Returns
+    -------
+    dict 
+        Contains the new basis vectors and the projected field components:
+        {'u_hat': array, 'v_hat': array, 'E_u': array, 'E_v': array}
+    """
+    u_arr = np.asarray(u, dtype=complex)
+    norm = np.linalg.norm(u_arr)
+    u_hat = u_arr / norm if norm > 0 else u_arr
+    
+    # Construct orthogonal vector v_hat
+    v_hat = np.array([-np.conj(u_hat[1]), np.conj(u_hat[0])], dtype=complex)
+
+    E_u = np.conj(u_hat[0]) * E1 + np.conj(u_hat[1]) * E2
+    E_v = np.conj(v_hat[0]) * E1 + np.conj(v_hat[1]) * E2
+
+    return {
+        "E_u": E_u,
+        "E_v": E_v,
+        "u_hat": u_hat,
+        "v_hat": v_hat,
+    }

vectorwaves/version.py

@@ -0,0 +1,5 @@
+"""
+Version information.
+"""
+current_version = (1, 0, 0)
+current_version_str = ".".join(map(str, current_version))

vectorwaves-1.0.0.dist-info/METADATA

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: vectorwaves
+Version: 1.0.0
+Summary: Three-dimensional electromagnetic field simulation and topology analysis
+Author: Mayank Soni
+License: MIT License
+        
+        Copyright (c) 2026 Mayank Soni
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/1Rayokelvin/VectorWaves
+Project-URL: Repository, https://github.com/1Rayokelvin/VectorWaves
+Project-URL: Issues, https://github.com/1Rayokelvin/VectorWaves/issues
+Project-URL: Documentation, https://1rayokelvin.github.io/VectorWaves
+Keywords: physics,optics,wave-optics,vector-optics,electromagnetism,electromagnetic-fields,structured-light,gaussian-beams,laguerre-gaussian,plane-wave-expansion,computational-physics,optical-singularities,polarization-singularities,phase-singularities,topological-optics,optical-vortices
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: numba>=0.59.0
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.7.0; extra == "viz"
+Requires-Dist: pyvista>=0.40.0; extra == "viz"
+Provides-Extra: progress
+Requires-Dist: tqdm>=4.65.0; extra == "progress"
+Provides-Extra: gpu
+Requires-Dist: cupy-cuda12x>=12.0.0; extra == "gpu"
+Provides-Extra: all
+Requires-Dist: matplotlib>=3.7.0; extra == "all"
+Requires-Dist: pyvista>=0.40.0; extra == "all"
+Requires-Dist: tqdm>=4.65.0; extra == "all"
+Requires-Dist: cupy-cuda12x>=12.0.0; extra == "all"
+Dynamic: license-file
+
+VectorWaves provides a framework for generating, computing, and analyzing fully three-dimensional electromagnetic fields and their topology through discrete plane-wave expansions.
+
+## Installation
+
+```bash
+pip install vectorwaves
+```
+
+For additional features, you can install the optional dependencies:
+
+| Extra | Purpose |
+|---------|---------|
+| `viz` | Matplotlib and PyVista for visualizations |
+| `progress` | Progress bars via tqdm |
+| `gpu` | CUDA acceleration via CuPy |
+| `all` | All the above |
+
+To install, 
+```bash
+pip install vectorwaves[extra]
+```
+
+## Features
+
+- Physics-oriented configuration system with `numpy`, `numba`, and CuPy (GPU) backends.
+- Exact non-paraxial 3D propagation via Fibonacci-sphere discrete plane-wave expansions.
+- Monochromatic and polychromatic sources with arbitrary envelopes, structured light support.
+- Stochastic process generation for speckle-like fields.
+- Fully analytic computation of E-fields, B-fields, spatial derivatives.
+- Topological polarization analysis: C, Cᵀ, and Lᵀ point finding with 3D line tracing.
+  
+## Quick Example
+
+```python
+import vectorwaves as vw
+
+# Generate a tightly-focused Laguerre-Gaussian beam
+config = vw.get_config()
+config.source.k_space.laguerre_gauss(p=1, l=2, sigma_k_perp=1)
+config.source.randomize.off()
+
+# Construct the beam and visualize its plane-wave modes
+beam = vw.setup_beam(config)
+
+# Requires matplotlib, install with  'viz' extra: pip install vectorwaves[viz]
+beam.plot_kspace_3d(plot_type='colored_vectors')
+```
+
+![LG beam k-space](https://github.com/1Rayokelvin/VectorWaves/blob/main/docs/images/LG_kspace.png?raw=true)
+
+For tutorials and examples, please refer to the [official documentation](https://1rayokelvin.github.io/VectorWaves). Source code is available on [GitHub](https://github.com/1Rayokelvin/VectorWaves/).

vectorwaves-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+vectorwaves/__init__.py,sha256=Rwj_-tdL6plfvaJL32xb1KXSfsZhO65YuyCC1akDBTc,1946
+vectorwaves/beam_stuff.py,sha256=K83C7oeftVECI-EFjUkvh48bh_V94QYCjnteZoHxPik,24702
+vectorwaves/config_stuff.py,sha256=hR6Z1woNeG4LrDtepidVwXykz4BGQQzJfrmaRJna_rY,29366
+vectorwaves/engine_stuff.py,sha256=yDW0moLDotWJJ0s4yK9Q4ZF-Po9ZXokBPZ8LpVS65ns,13036
+vectorwaves/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwaves/singularities.py,sha256=BkN0OJdDPzzp_5hbezVifGO-y8ERkUlHkkJ4aXWvcTE,29030
+vectorwaves/spectra.py,sha256=jqZboP7SYneFB_L7KWbzlkhygSk-WmWorNKbgAIhmns,11050
+vectorwaves/utils.py,sha256=gQh4qCjy6ADsCVqSlypEgoZLM72bafiQU5wX4IBnt2w,4150
+vectorwaves/version.py,sha256=HhR0jXvoPPIUm_TZEYrtIkepM8kImipNVYUUXhnyY98,118
+vectorwaves/backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwaves/backends/cupy_backend.py,sha256=ih26VgQfaZrThup2Z0zHTFFDV6WsMro7lLAsOpiCmwQ,8213
+vectorwaves/backends/numba_backend.py,sha256=sapN0XeC9dpQNTxU28njbV9sSjnzyvE9ACHXhJy_wKg,11364
+vectorwaves/backends/numpy_backend.py,sha256=8qj8OdiSeW1D0NPlVopwb9TTFqFjfzFr5ZBz9CL_Vj0,7212
+vectorwaves-1.0.0.dist-info/licenses/LICENSE,sha256=MXeu576i1y4CBMZHHPxEe1VUAetK1JJ-uGg2vqM-8y4,1087
+vectorwaves-1.0.0.dist-info/METADATA,sha256=f_klnEXzh_sirGdTaNrdj0yOaN6HLsoDJ5lDHYfY7H8,5151
+vectorwaves-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+vectorwaves-1.0.0.dist-info/top_level.txt,sha256=jpIC3lf8s6nySEu9pjTMjkK-kmtLARl07cvHdmEwl9g,12
+vectorwaves-1.0.0.dist-info/RECORD,,

vectorwaves-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

vectorwaves-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mayank Soni
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vectorwaves-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+vectorwaves