Researchers in physics and physical chemistry from the University of Southampton credit ArrayFire in a scientific report for its help in drastically reducing computation time of linear algebra, vectored mathematical operations, and fast Fourier transforms (FFT). The report examines high-energy laser pulse self-compression in short gas-filled fibers.

**Research Abstract**

From the article in Physical Review, the following abstract summarizes the research:

We examine the spatio-temporal compression of energetic femtosecond laser pules within short gas-filled fibers. The study is undertaken using an advanced nonlinear pulse propagation model based on a multimode generalized nonlinear Schr ̈odinger equation that has been modified to include plasma effects. Plasma defocusing and linear propagation effects are shown to be the dominant processes within a highly dynamical mechanism that enables 100 fs pulses to be compressed into the few-cycle regime after <50 mm of propagation. Once the mechanism has been introduced, parameter spaces are explored and compressor designs suitable for performing high-field experiments in-situ are presented. We finish by showing how these designs may be extended to novel wavelengths and driving pulses delivered by state-of-the-art high repetition rate lasers.

To accelerate the processing speed, open source ArrayFire library based on CUDA technology which could enable parallel computing on GPU was introduced to make this comparison. The below image does a comparison showing **an order of magnitude improvement with GPGPU computing using ArrayFire**.

**ArrayFire GPGPU vs. CPU Computation Speed**

The authors state that they implemented a simulation in C++ with the use of the ArrayFire library to compare the computational speed of the CPU vs a GPGPU using ArrayFire.

From the above figure (a), we can see as the temporal grid size increases the computation time greatly increases if we are running off of the CPU. This will take a lot of computation as the temporal grid size increases. Just one unit of increase on the temporal grid size from 5000 units to 15,000 units can cause the computation time to go from approximately **50** seconds to approximately **350** seconds. This computation would take approximately **800** seconds for a temporal grid of 30,000 units.

Now, if we are running from the GPGPU using ArrayFire, that will bring the computation time from approximately **50** seconds down to approximately **20** seconds for a 5000-unit temporal grid which is less than half the computation time. At 30,000-units the operation will take approximately **500** seconds down from **800**. This is a great example of how ArrayFire allows its users to make more computations in less time.

From the figure (b), we can see that as the transverse spatial mode increases the computation time greatly increases as well. First, we will look at the computation times of the CPU. If we compare the time it takes to complete computations on 10 transverse spatial modes, it will take approximately **90** seconds. If we attempt to run 40 transverse spatial modes, it will take approximately **1000** seconds.

Now if we are running from the GPGPU using ArrayFire, that will bring the computation down from approximately **90** seconds to approximately **20** seconds to compute 10 transverse spatial nodes. If we try to compute 40 spatial nodes it will take approximately **80** seconds down from **1000** seconds.