Package: pyfastnoisesimd
PyFastNoiseSIMDPyFastNoiseSIMD is a wrapper around Jordan Peck's synthetic noise libraryhttps://github.com/Auburns/FastNoise-SIMDwhich has been
accelerated with SIMD instruction sets. It may be installed via pip:pip install pyfastnoisesimdParallelism is further enhanced by the use ofconcurrent.futuresto multi-thread
the generation of noise for large arrays. Thread scaling is generally in the
range of 50-90 %, depending largely on the vectorized instruction set used.
The number of threads, defaults to the number of virtual cores on the system. The
ideal number of threads is typically the number of physical cores, irrespective
of Intel Hyperthreading®.Here is a simple example to generate Perlin-style noise on a 3D rectilinear
grid::import pyfastnoisesimd as fns
import numpy as np
shape = [512, 512, 512]
seed = np.random.randint(2**31)
N_threads = 4

perlin = fns.Noise(seed=seed, numWorkers=N_threads)
perlin.frequency = 0.02
perlin.noiseType = fns.NoiseType.Perlin
perlin.fractal.octaves = 4
perlin.fractal.lacunarity = 2.1
perlin.fractal.gain = 0.45
perlin.perturb.perturbType = fns.PerturbType.NoPerturb
result = perlin.genAsGrid(shape)whereresultis a 3Dnumpy.ndarrayof dtype'float32'. Alternatively,
the user can provide coordinates, which is helpful for tasks such as
custom bump-mapping a tessellated surface, viaNoise.getFromCoords(coords).More extensive examples are found in theexamplesfolder on the Github repository.Parallelism is further enhanced by the use ofconcurrent.futuresto multi-thread
the generation of noise for large arrays. Thread scaling is generally in the
range of 50-90 %, depending largely on the vectorized instruction set used.
The number of threads, defaults to the number of virtual cores on the system. The
ideal number of threads is typically the number of physical cores, irrespective
of Intel Hyperthreading®.DocumentationCheck it out at:http://pyfastnoisesimd.readthedocs.ioInstallationpyfastnoisesimdis available on PyPI, and may be installed viapip::pip install --upgrade pip
pip install --upgrade setuptools
pip install -v pyfastnoisesimdWheels are provided for Windows, Mac OSX, and Linux viamanywheels.Building from source on Windows will require the appropriate MS Visual Studio
version for your version of Python, or MSVC Build Tools:http://landinghub.visualstudio.com/visual-cpp-build-toolsOn Linux or OSX, only a source distribution is provided and installation
requiresgccorclang. For AVX512 support with GCC, GCC7.2+ is required, lower
versions will compile with AVX2/SSE4.1/SSE2 support only. GCC earlier than
4.7 disables AVX2 as well. Note thatpipdoes not respect the$CCenvironment
variable, so to clone and build from source withgcc-7:git clone https://github.com/robbmcleod/pyfastnoisesimd.git
alias gcc=gcc-7; alias g++=g++-7
pip install -v ./pyfastnoisesimdInstalling GCC7.2 on Ubuntu (withsudoor as root)::add-apt-repository ppa:ubuntu-toolchain-r/test
apt update
apt install gcc-7 g++-7BenchmarksGenerally speaking thread scaling is higher on machines with SSE4 support only,
as most CPUs throttle clock speed down to limit heat generation with AVX2.
As such, AVX2 is only about 1.5x faster than SSE4 whereas on a pure SIMD
instruction length basis (4 versus 8) you would expect it to be x2 faster.The first test is used the default mode, a cubic grid,Noise.genAsGrid(),
fromexamples\gridded_noise.py:Array shape: [8,1024,1024]CPU: Intel i7-7820X Skylake-X (8 cores, 3.6 GHz), Windows 7SIMD level supported: AVX2 & FMA3Single-threaded modeComputed 8388608 voxels cellular noise in 0.298 s
    35.5 ns/voxel
Computed 8388608 voxels Perlin noise in 0.054 s
    6.4 ns/voxel

Multi-threaded (8 threads) modeComputed 8388608 voxels cellular noise in 0.044 s
5.2 ns/voxel
685.0 % thread scaling
Computed 8388608 voxels Perlin noise in 0.013 s
1.5 ns/voxel
431.3 % thread scalingThe alternative mode isNoise.getFromCoords()where the user provides the
coordinates in Cartesian-space, fromexamples\GallPeters_projection.py:Single threaded modeGenerated noise from 2666000 coordinates with 1 workers in 1.766e-02 s
    6.6 ns/pixel

Multi-threaded (4 threads) modeGenerated noise from 2666000 coordinates with 4 workers in 6.161e-03 s
2.3 ns/pixel
286.6 % thread scalingRelease Notes0.4.2Wheels are now built via GitHub Actions and available on PyPi.Support for Python 3.8 and 3.9 added. Support for Python 3.5 was dropped.0.4.1Support for Python 3.7 now official. On Windows AVX512 is still disabled as
even with MSVC2017.3 some of the required SIMD instructions are unavailable.0.4.0Fixed aligned memory location on Windows and enabled multi-threaded processing
for both generators.renamedemptyCoordsfunction toempty_coords.0.3.2Disabled aligned memory allocation on Windows, due to it causing seg-faults.Thanks to Luke H-W for finding and fixing a memory leak ingenAsGrid.Thanks to Enderlook for reporting that thestartparameter was not working
in multi-threading mode for calls togenAsGrid.0.3.1Changes to calling convention to avoid pointer size confusion between 64- and
32-bit OSs.0.3.0Elliott Sales de Andrade fixed a number of issues with installation to
build cleanly and better handle CPU SIMD capabilities.Added multi-threaded operation toNoise.genFromCoords().Addedorthographic_projection.pytoexamples/.Updated doc-strings to accommodatesphinx.napoleonformatting.Added Sphinx-docs in thedocdirectory.Corrected spelling errorPerturbType.NoPetrub->PerturbType.NoPerturbStoppedfastnoisesimdfrom freeing memory forcoordsargument ofNoise.genFromCoords(coords).  It should now be possible to reuse
coords without seg-faulting.0.2.1Drop explicit Python 3.4 support as we cannot test it for Windows on MSVC2010
and in any case it wouldn't have AVX2 instruction support.Start tagging, seeRELEASING_GUIDE.txtfor notes.0.2.0Added the capability to provide coordinatesAddedexamples/projection.pyto demonstrate noise generation by supplied
coordinates as applied to a Gall-Peters cylindrical projection of a sphere
(i.e. a world map).AddedNoiseobject-oriented interface.Noiseuses Python properties to
expose theSet/Getfunctions inFastNoiseSIMD.Addedunittestsupport.Deprecated 'kitchen sink'pyfastnoisesimd.generate()function.Changed README from markdown to rich-structured text.Fixed a bug in the deprecatedpyfastnoisesimd.generate()that always set
the seed to 42.Fixed spelling errors:axisScales->axesScales,indicies->indices0.1.5Using all lower-case directories for *nix.0.1.4Fixed bug on multithreading; current approach splits arrays up to min(threads, array.shape[0])0.1.2Added MANIFEST.in file for source distribution on PyPIFastNoiseSIMD libraryIf you want a more direct interface with the underlying library you may use thepyfastsimd._extmodule, which is a function-for-function mapping to the C++
code.FastNoiseSIMD is implemented by Jordan Peck, and may be found at:https://github.com/Auburns/FastNoiseSIMDIt aims to provide faster performance through the use of intrinsic(SIMD) CPU
functions. Vectorisation of the code allows noise functions to process data in
sets of 4/8/16 increasing performance by 700% in some cases (Simplex).See the Wiki for usage information on the noise types:https://github.com/Auburns/FastNoiseSIMD/wikiDownload links for a GUI-based reference noise generator may be found at:https://github.com/Auburns/FastNoiseSIMD/releasesAuthorsRobert A. McLeod wrote the Python wrapper, implemented multi-threading, and
wrote the documentation.Elliott Sales de Andrade contributed a number of fixes to allow building to
succeed on many platforms.Jordan Peck wrote the underlying libraryFastNoiseSIMD.