M>Для чистоты экперимента — без нестандартных зависимостей, чтобы мне, не работавшему с плюсами много веков, не так сложно было собирать и запускать этот код

#include <iostream>
#include <iomanip>
#include <complex>
#include <vector>
#include <numeric>

typedef std::complex<double> complex;
typedef std::vector<complex> chunk;

// вот начинается наша реализация векторной арифметики
chunk& operator*=(chunk& lhs, const chunk& rhs)
{
    for (size_t k = 0; k < lhs.size(); k++)
        lhs[k] *= rhs[k];
    return lhs;
}

chunk operator*(const chunk& lhs, const chunk& rhs)
{
    chunk res(lhs);
    return res *= rhs;
}
// а вот она закончилась.

int main()
{
    std::cout << std::fixed << std::setprecision(1);

    auto i = complex(0., 1.); // определили корень из минус единицы

    auto const s = 40000;
    auto data = std::vector<complex>(s, i); // создали массив размером в s элементов из i

    auto data2 = data * data; // возвели его в квадрат при помощи только что навелосипеженного оператора умножения

    auto sum = std::accumulate(data2.begin(), data2.end(), complex(0.)); // посчитали сумму массива
    std::cout << "sum(data2[]) = " << sum << '\n'; // чтобы проверить, что она равна -s.
    

}

data3_as_doubles[2*i] = data1_as_doubles[2*i]*data2_as_doubles[2*i]-data1_as_doubles[2*i+1]*data2_as_doubles[2*i+1];
data3_as_doubles[2*i+1] = data1_as_doubles[2*i]*data2_as_doubles[2*i+1]+data1_as_doubles[2*i+1]*data2_as_doubles[2*i];

S>data3_as_doubles[2*i] = data1_as_doubles[2*i]*data2_as_doubles[2*i]-data1_as_doubles[2*i+1]*data2_as_doubles[2*i+1];
S>data3_as_doubles[2*i+1] = data1_as_doubles[2*i]*data2_as_doubles[2*i+1]+data1_as_doubles[2*i+1]*data2_as_doubles[2*i];
S>

Vector result = v1 * v2 * v3 * v4;

M>>Для чистоты экперимента — без нестандартных зависимостей, чтобы мне, не работавшему с плюсами много веков, не так сложно было собирать и запускать этот код

EP>Пока ты редактировал сообщение, я уже сделал в таком виде Убрать зависимость boost конечно не сложно, но давай уже сделаем это после того как увидим Java версию.

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;

import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

@OutputTimeUnit(TimeUnit.MILLISECONDS)
@State(Scope.Thread)
@Fork(1)
@Warmup(iterations = 10)
@Measurement(iterations = 10)
@BenchmarkMode(Mode.AverageTime)
public class ComplexTest2 {

    private static class ComplexFlyweight
    {
        private final double[] ar;

        public ComplexFlyweight(double[] ar) {
            this.ar = ar;
        }

        public double re( int i )
        {
            return ar[ i *2 ];
        }

        public double im( int i )
        {
            return ar[ i * 2 + 1 ];
        }

        public void re( int i, double v )
        {
            ar[i * 2] = v;
        }

        public void im( int i, double v )
        {
            ar[i * 2+1] = v;
        }
    }

    private static final int N = 1 << 24;

    private double[] u_ar = new double[ N * 2 ];
    private double[] v_ar = new double[ N * 2 ];
    private ComplexFlyweight u = new ComplexFlyweight( u_ar );
    private ComplexFlyweight v = new ComplexFlyweight( v_ar );

    @Setup
    public void setup()
    {
        for ( int i = 0; i < v_ar.length; ++i ) {
            u_ar[i] = ThreadLocalRandom.current().nextInt( 32767 ) / 1000. - 1000.;
            v_ar[i] = ThreadLocalRandom.current().nextInt( 32767 ) / 1000. - 1000.;
        }
    }

    @Benchmark
    public double testVectorMult()
    {

        for ( int i = 0; i < u_ar.length / 2; ++i ) {
            v.re(i, u.re(i) * v.re(i) - u.im(i) * v.im(i) );
            v.im(i, u.re(i)*v.im(i) + u.im(i)*v.re(i));
        }
        return u.re( 0 );
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(".*" + ComplexTest2.class.getSimpleName() + ".*")
                .build();

        new Runner(opt).run();
    }
}

# Warmup: 10 iterations, 1 s each
# Measurement: 10 iterations, 1 s each
# Threads: 1 thread, will synchronize iterations
# Benchmark mode: Average time, time/op
# Benchmark: info.javaperformance.gccheck.ComplexTest2.testVectorMult

# Run progress: 0.00% complete, ETA 00:00:20
# Fork: 1 of 1
# Warmup Iteration   1: 60.429 ms/op
# Warmup Iteration   2: 58.038 ms/op
# Warmup Iteration   3: 58.117 ms/op
# Warmup Iteration   4: 57.762 ms/op
# Warmup Iteration   5: 57.733 ms/op
# Warmup Iteration   6: 57.863 ms/op
# Warmup Iteration   7: 57.885 ms/op
# Warmup Iteration   8: 57.698 ms/op
# Warmup Iteration   9: 57.609 ms/op
# Warmup Iteration  10: 57.925 ms/op
Iteration   1: 57.761 ms/op
Iteration   2: 57.685 ms/op
Iteration   3: 57.779 ms/op
Iteration   4: 57.570 ms/op
Iteration   5: 57.640 ms/op
Iteration   6: 57.743 ms/op
Iteration   7: 57.762 ms/op
Iteration   8: 57.696 ms/op
Iteration   9: 57.668 ms/op
Iteration  10: 57.756 ms/op


Result: 57.706 ±(99.9%) 0.101 ms/op [Average]
  Statistics: (min, avg, max) = (57.570, 57.706, 57.779), stdev = 0.067
  Confidence interval (99.9%): [57.605, 57.807]


# Run complete. Total time: 00:00:25

Benchmark                            Mode  Samples   Score  Score error  Units
i.j.g.ComplexTest2.testVectorMult    avgt       10  57.706        0.101  ms/op